来自学霸的万字分享，Python基础知识点总结，码住收藏！

现在挺多小伙伴都在学Python，其中包括很多零基础的初学者，知识点这方面可能不熟悉。想必大家都想通过学习完成逆袭！

我找到了我当初学python的笔记，特地请教过当时我们学校的学霸级大佬学长，压箱底的都给你们翻出来了，我根据我笔记肝出万字Python知识点大总结！

文章篇幅有点长，请耐心读完吧！

一、Python基础必备

1、什么是Python

Python是门程序设计语言

• 自然语言：人能听懂的语言（汉语，英语，法语…）

• 机器语言：机器能听懂的语言（01010101）

• 程序设计语言：机器能够听懂，人能听懂的语言（Python，C，C++ C# Java）

• 语法规范

  高级程序设计语言：越接近于人类的语言越高级

  低级程序设计语言：越接近于机器语言越低级（汇编）

2、Python 的历史

• 创始人：Guido van Rossum --龟叔
• 时间：1989圣诞节期间，构思Python这门语言
• Python来自于《Monty Python’s Flying Circus》《蒙提·派森的飞行马戏团》–小品
• 2020.11.12加入微软的开发部门

3、Python的特点

• 语法简洁（通过文本缩进的形式）
• 有着非常强大的类库
• 胶水语言（调用其他语言的类库）
• 代码量较少

4、Python 运行机制

程序员：代码（源文件）

• 编译型

  将源文件通过编译器，编译成机器码文件，当运行的时候直接执行机器码文件

  缺点：不能跨平台
  优点：执行快

• 解释型

  将源文件通过解释器，逐行进行翻译并运行

  缺点：执行慢
  优点：可以跨平台（操作系统）

• Python的运行机制

  1. 解释运行（脚本）
  2. 先编译后解释

5、Python的安装

• 官网：www.python.org

• 勾选add Python** to PATH

• 验证Python是否安装成功

  通过黑窗口（cmd）输入Python测试

6、helloworld

• 开发工具：

  idle 文本编辑器，支持交互式界面

  pycharm 文本编辑器

• 创建源文件

  *.py

• 编译源文件

  print(“helloworld”)

• 运行Python文件

  点击run run Module F5

7、print（）

输出函数（功能）

• print(要输出的内容)
  py2: print 要输出的内容
  py3：print(要输出的内容)

• print()

  默认有换行功能

print(输出的内容,end='\n')  #end是以...结尾  “\n” 转义字符：换行

8、input()

输入语句
input(“提示信息”)

input(“请输入密码：”)

input接收到的内容全是字符串

9、变量

• 就是一个名字

• 先赋值在使用

• 变量要符合标识符(名字)的命名规范

10、标识符的命名规范

标识符–名字(变量名，函数名，类名…)
语法规范：硬性要求

• 合法的标识符:字母，数字(不能开头),下划线
  py3可以用中文（不建议）
  py2不可以

• 大小写敏感

• 不能使用关键字和保留字
  关键字： if while for as import
  保留字：input，print range

• 没有长度限制

• 望文生义
  看到名字就知道要表达的意思

• 大小写
  1. 包名：全小写
  2. 类名：每个单词的首字母大写其他的小写（驼峰命名法）大驼峰
  3. 变量名/函数名:第一个单词的首字母小写，后面的单词的首字母大写(小驼峰)
  4. 常量：全大写

• 其他命名方式

  hello_world

11、数据类型

• 整型：int 整数

• 浮点型： float 小数
  表现形式：
  小数
  科学计数法 e表示乘以10几次方
  a=5e-1 b=1e10 #1*10的10次方

• 字符串：str
  形式：’’ “” “”“xsxs”"" ‘’’‘xxx’’’
  三引号特殊功能：表示注释：
  #注释
  三引号注释：
  “”
  xsx
  xs
  “”"

• 布尔类型： bool
  True: 真
  False:假
  1表示真
  0表示假

• None

• 列表，元组，字典，集合…

12、类型转换

• 字符串转整型

   int(str) 
   user = int('304200780') #字符串必须是数字

• 浮点型转整型

   int(float)
   f = 20.1
   ff = int(f) #直接抹去小数部分

• 字符串转浮点型

   float(str)  #字符串必须是数字和.
   f = "203.4"
   ff = float(f)

• 整型转浮点型

   float(int)
	   f=30
	   float(f) #30.0

• 浮点型转字符串

   str(float)
   f = 30.5
   ff = str(f) #字符串"30.5"

• 整型转字符串

   str(int) 
   f=30 
   str(f) #字符串"30"

13、 获取类型信息

• type()
  type(对象)–返回对象的类型

• isinstance(对象,class)
  返回布尔值（True,False）

14、 表达式

表达式都有固定字面值

字面值：所有值 10+20 a+b（a=10,b=20） 10>30

10:整型int的字面值

例如：

b=“hehe”

a=“heiehi”

a+b

15、运算符

• 一般运算符
  +，-，*，/（真除法）

  //（地板除，舍去小数部分）,%（取余数）,**（幂运算）

• 赋值运算符
  =：等号右边的值赋值等号左边
  增强赋值运算符：
  +=，-=，*=，/=,%=,**=
  连续赋值：
  a=b=c=d=10

• 布尔运算法
  == （等于），！=（不等于） ，>= （大于等于），<= （小于等于），>， <

• 逻辑运算符

  not 非
  and 与
  or 或
  and：前后都为真则为真
  or：有一个为真则为真
  not:非真，非假

---

二、流程控制

1、 条件分支流程：当达到某种条件的时候才会触发的代码

语法1：
	if 布尔表达式: #如果为真则执行内部的代码块
		代码块
		
语法2：
	if 布尔表达式：#如果为真则执行if内部的代码块,如果为假则执行else内部的代码
		代码块
	else:
		代码块
        
     实例：  a = 10
            b = 20
            if a>b:
                a = 30
                print(a)

            else:
                print(1111)
 语法3：
		if 布尔表达式：#如果为真则执行if内部的代码块,如果为假则执行else内部的代码
			代码块
        elif 布尔表达式：
        	代码块
        elif 布尔表达式：
        	代码块
        ....
		else:
			代码块
   实例：
        
        s = int(input("请输入分数:"))

        if 80>=s>=60:
            print("及格")
        elif 80<s<=90:
            print("优秀")

        elif 90<s<=100:
            print("非常优秀")

        else:
            print("不及格")
 语法4:
    嵌套使用
    s = int(input("请输入分数:"))
    if 80>=s>=60:
        print("及格")
    elif 80<s<=90:
        print("优秀")
    elif 90<s<=100:
        print("非常优秀")
    else:
        print("不及格")
        if s>50:
            print("你的分数在60分左右")
        else:
            print("你的分数低于50分")

2、循环流程

重复运行某些代码

1. while
	语法：
		while 布尔表达式: #只要条件为真就执行
			代码块
			
		实例：
			while 4<5:
                s = int(input("请输入分数:"))
                if 80>=s>=60:
                    print("及格")
                elif 80<s<=90:
                    print("优秀")
                elif 90<s<=100:
                    print("非常优秀")
                else:
                    print("不及格")
                    if s>50:
                        print("你的分数在60分左右")
                    else:
                        print("你的分数低于50分")
         解决死循环问题：
         	a=3
            while a<5:
                s = int(input("请输入分数:"))

                if 80>=s>=60:
                    print("及格")
                elif 80<s<=90:
                    print("优秀")
                elif 90<s<=100:
                    print("非常优秀")
                else:
                    print("不及格")
                    if s>50:
                        print("你的分数在60分左右")
                    else:
                        print("你的分数低于50分")
                a+=1
            print(a)
            print("while执行结束了")
            
      案例：
      #请输入一个整数，并计算各个位和 如：321=6

        n = int(input("请输入一个整数:"))#将字符串转为整型

        #sums累加器：m=10 m=10+5

        sums = 0

        while n!=0: #32 #3
            sums=sums+n%10  #sums=1+2=3+3=6
            n=n//10 #32
        print(sums)
2. for循环 --计数循环
	
		语法：l=[3,2,1]
			for 变量 in l(可迭代对象):
				代码块
3. range()
	可迭代对象
	(1)range(stop)
		返回一个序列从0开始到stop-1为止
	(2)range(start=0,stop,step=1)
	
        for i in range(0,10,2):  
            print(i)
            print("helloworld")
        for i in range(10,2,-2):  
            print(i)
            print("helloworld")    
4. break
	跳出循环，后面循环不在执行
        a=5
    	for i in range(1,10):  
            if i==5:
                break
            print(i)
            print("helloworld")
5. continue
	跳过本次循环，后面的循环继续执行
        a=5
        for i in range(1,10):  
            if i==5:
                continue
            print(i)
            print("helloworld")

---

三、列表(List)

可以存放任何数据，整型，浮点型，字符串，布尔型…

最常用的数据类型之一

1、 列表的创建

列表也是一个可迭代对象

• 普通形式

  l = [1,2,3,4,5] —整型列表
  l = [“a”,“b”,“c”] —字符串列表
  l = [True,False,1>2,5<6]—布尔列表

• 混合列表

  l = [1,2.5,“a”,True]

• 空列表

  l = []

2、从列表中如何获取数据(元素)

列表是有下标的，并且下标从0开始
l = [5,4,3,2,1] 元素是指列表中每个数据

• 1.获取当个数据(元素)

语法：
	变量[下标] #获取下标所对应的值
	l = [1,2,3] #下标/索引：0开始
	print(l[1])

• 列表的遍历

for i in l:
	print(i,end=" ")

• 交换数据

l = [1,2,3,4,5] #下标/索引：0开始
l[2],l[3] = l[3],l[2]
print(l)

3、添加元素

• append(对象)

向列表中添加数据，并添加到末尾
变量.append(数据)

• extend(可迭代对象)

#将可迭代对象中数据分别添加到列表中，并添加到末尾
l.extend([6,7])
print(l)

• insert(下标,对象)

l.insert(3,6)
print(l)

4、 删除元素

• clear()

  清空列表

• pop([下标])

  删除下标指定的元素，如果不加下标则删除最后一个元素
  l.pop(3)
  print(l)

• remove(value)

  删除指定的值
  l.remove(4)
  print(l)

• del 语句

  del l ： 删除变量I
  del l[3] ： 删除列表中下标为3的数据
  print(l)

5、修改

修改列表中元素
 语法：
	变量[下标]=新值
l[2]=6

print(l)

6、列表高级特性的

切片操作,分片

• 语法：
  变量[起始下标:结束下标] #结束下标取不到
  如果下标从0开始可以省略不写 n = l[:4]
  如果结束下标取的是最后一个元素，可以省略不写 n = l[3:]
  如果列表中的元素都要 开始和结束下标都可以省略 n = l[:]
  n = l[:-1] 从0开始-到数二个元素

• 列表的进阶操作

n = l[开始:结束:步长]
n = l[-9:-1:2]
n = l[-1:-9:-2]

7、列表的一些操作符

• 比较运算符

l = [1,2,3,4,5,6,7,8,9,10] #下标/索引：0开始
l2 = [2,3,4,6]
print(l < l2) #True
列表之间进行比较，以相同下标进行比较，从小到大进行比较，如果值相同则比较下一组元素，如果不同直接出结果

• 逻辑运算符
  and not or
• 拼接运算符

+
print(l + l2)

• 重复操作符

 *

• 成员关系操作符

in    not in
判断元素是否在列表中
print(5 not in l)

8、列表的其他方法

• copy()
  浅拷贝

• count(value)
  返回value在列表中出现的次数
  n = l.count(6)
  print(n)

• index(value,[开始下标],[结束下标])
  元素出现的第一次下标位置，也可自定义范围
  n = l.index(6,8,9)
  print(n)

• reverse()
  原地翻转
  l.reverse()
  print(l)

• sort（key=None，reverse=False）

  快速排序
  默认从小到大排序
  key:算法

9、 冒泡排序

给定一个列表
	l = [5,4,3,2,1],用冒泡排序的思想从小到大排序

让列表中两个相邻的元素，进行比较，如果不符合条件那么就互换位置

len():获取列表的长度（元素）

案例：
#给定一个列表
	# l = [5,4,3,2,1],用冒泡排序的思想从小到大排序
	
        l = [6,5,4,3,2,1]
        for i in range(1,len(l)): #1,5 #循环4大次  4
            for j in range(len(l)-i):
                if l[j] >l[j+1]:
                    l[j],l[j+1] = l[j+1],l[j]

        print(l)

10、选择排序

#给定一个列表
	# l = [5,4,3,2,1],用选择排序的思想从小到大排序

选择排序：让列表中的元素，固定一个元素和其他元素进行比较，不符合条件互换位置
l = [6,5,4,3,2,1]
for i in range(0,len(l)-1):#0,4
    for j in range(i+1,len(l)): #1,5
        if l[i] >l[j]:
            l[i],l[j]=l[j],l[i]

print(l)

11、二维列表

列表中的列表
l = [[1,2,3],[4,5,6],[7,8,9]]
语法：
	变量[外层列表下标][内层列表的下标]
l[0][1] #2


for遍历：
	l = [[1,2,3],[4,5,6],[7,8,9]]
    for i in l:
        for j in i:
            print(j)

四、元组（tuple）

存放任何数据类型

• 不能修改，不可变类型
• 用（）的形式
• 元组也是可迭代对象
• 元组是有序的，下标操作,支持切面操作[:]

1、元组的创建及访问

• 创建：
  直接创建： t = (1,2,3,4,5)

• 访问：
  t[下标] 获取元素

• 切片操作：
  t[:] 返回元组

2、 修改和删除

• 修改：

#先转换成列表进行修改，然后再转换回来
	t = (1,2,3,4,5)
    print(t[1:4])
    l = list(t)
    print(l)
    l[2]=6
    print(l)
    t=tuple(l)
    print(t)

• 删除：

del t   #删除变量

3、元组的操作符

• 比较运算符
  < > >= <= == !=

• 逻辑运算符
  and not or

• 拼接运算符
  +

• 重复操作符
  *

• 成员关系操作符

  in not in
  判断元素是否在列表中
  print(5 not in l)

4、元组的方法

• count(value)

  value出现的次数

• index(value,[start],[stop])

  返回value再元组中出现的下标位置（第一次出现的下标）

---

五、字符串

1、 字符和字符串

Python中字符和字符串没有区别
字符：单个字符
字符串：一个字符串对象（）
Java：
字符：单引号’a’
字符串：双引号：“abc”

2、字符串的特点

• 字符串不可变类型

• 字符串是可迭代对象

• 字符串支持索引和切片操作

• 支持操作符;

  拼接：+
  重复操作符：*
  比较运算符： > < <= >= == !=
  逻辑运算符：not and or
  成员关系： in not in

3、字符串的方法

• capitalize()
  把字符串的第一个字符改为大写，后面的小写
  b = a.capitalize()
  print(b)

• casefold()
  把整个字符串都小写
  b= a.casefold()
  print(b)

• encode()
  编码 str–bytes（二进制字符串）

• decode()
  解码

• count(sub,[start],[stop])
  返回字符（sub）出现的次数
  n = a.count(“L”)
  print(n)

• find(sub,[start],[stop])
  返回sub第一次出现的下标,查不到返回-1

• index(sub,[start],[stop])
  返回sub第一次出现的下标，报错

• upper()
  将字符串转为大写

• lower()
  将字符串转为小写

4、 格式化

按照某种格式输出

1.format
语法1：用数字占位（下标）
		
		"{0} 嘿嘿".format("Python")
		a=100
		s = "{0}{1}{2} 嘿嘿"
		s2 = s.format(a,"JAVA","C++")
		print(s2)
	语法2：
		{} 占位
			a=100
        s = "{}{}{} 嘿嘿"
        s2 = s.format(a,"JAVA","C++","C# ")
        print(s2)
    语法3：用字母占位
    	s = "{a}{b}{c} 嘿嘿"
		s2 = s.format(b="JAVA",a="C++",c="C# ")
		print(s2)

2. %s
“%s”%（值）
最常用的参数可以是任意值
九九乘法表:
	for i in range(1,10):
        for j in range(1,i+1):
            print("%s * %s = %s"%(i,j,i*j),end="\t")
        print()

5、转义字符

• “\n” ：换行符
• “’”:单引号
• “\“”:双引号
• “\” : \

反斜杠应用：

a= "sxsxsxsxsxsxsxs\
    xsxsxsxs\
    xsx"
    print(a)


a= 1+2+3\
	+4
print(a)

六、字典（dict）

存储数据，以映射关系存储

1、字典的特点

• 字典是Python中唯一的映射类型
  name – “不良人”

• 字典是无序的

• 字典是可迭代对象

• 字典的构成

  键：key
  值：value
  映射：键–值
  键-值：键值对（项）

2、创建字典

• 直接创建

    d = {} #空字典
	d = {"name":"不良人","apple":"苹果"}

• dict()

    d = dict()

• dict(可迭代对象)

   d3 = dict([("one",1),("two",2)])
   print(d3)

• **dict(kwargs)

   d4 = dict(a=3,b=4)
   print(d4)

3、字典访问的

• 基本形式：

变量名[键名] #键所对应的值
d = {"name":"小黑"}
print(d["name "])

• 添加一个键值对

  变量名[键名]=值

• 修改一个键值对的值

  变量名[键名]=值

4、字典的方法

• clear()
  清空字典
• copy()
  浅拷贝
• fromkeys(可迭代对象，value=None)
  根据可迭代对象中的元素去创建字典

   d = {"name":"小黑"}
   d2 = d.fromkeys([1,2,3,4],[4,5,6,7])
   print(d2)

• get(key,[d])
  key：键
  d：提示信息

   d = {"name":"小黑"}
   print(d.get("name2","没有查到"))、

• items()
  将字典中的键值对封装成元组并放到类集合中

   d2={'c': 3, 'hehe': 100, 'b': 2, 'a': 1}
   s = d2.items()
   print(list(s))

• keys()
  同上，取键

• pop(key,[d])
  根据键删除字典中的键值对
  d:提示信息

• popitem()
  删除某个键值对

• values()
  返回字典中的值（类集合对象）

   d2={'c': 3, 'hehe': 100, 'b': 2, 'a': 1}
   c= d2.values()
   print(list(c))

5、补充

• 字典可以使用for循环

    for i in d2:
	   print(i) #键，不包含值

• 输出一个键值对

    for i in d2.items():
	   print(i)

• 成员关系操作符

  in/not in
  只能查询键

七、函数

由一组代码组成，完成某个特定的功能

• 创建函数：
  语法：
  def 函数名([参数]): #参数相当于变量,参数可以为多个，逗号隔开，还可以没有参数=无参
  代码块（函数的实现/函数体）

• 函数的调用

  函数名(参数)

1、函数的运行机制

• 从函数调用开始执行

• 通过函数名字找到函数定义的位置（创建函数的位置）

• 执行函数体

• 执行完毕之后，返回到函数的调用处

2、函数的使用

def fun2(a,n):
    print(a*n)


 #打印古诗
print("白日依山尽")
fun2("+",5)
print("黄河入海流")
fun2("-",10)
print("欲穷千里目")
fun2("*",15)
print("更上一层楼")
fun2("/",20)

3、函数的特点

• 避免了代码的冗余

• 提高了代码的可维护性

• 提高了代码的可重用性

• 提高了代码的灵活性

4、 函数的参数

• 形式参数：形参
  在定义函数的时候传递的参数

• 实际参数：实参
  在调用函数时传递的参数

• 无参
  没有任何参数

位置参数：
	和位置有关系--一一对应，不能多也不能少
	def fun4(a,b,c,d):
    	print(a,b,c)
	fun4(10,20,30)
关键字参数：
	定义关键字的参数--实参
	def fun4(a,b,c):
    	print(a,b,c)

	fun4(b=10,a=20,c=30)
位置参数和关键字参数混用：
	当位置参数和关键字参数混用时，位置参数在前
	def fun4(a,b,c):
    	print(a,b,c)
	fun4(10,20,c=30)
默认参数：
	给了默认值的参数--形参
	如果传递了新的值，那么默认值就被覆盖了
	def fun4(a=10,b=20,c=30):
    	print(a,b,c)

	fun4()
	fun4(20,30,40)
	fun4(b=20,c=30,a=40)
可变成参数：
	def 函数名(*a)
	本质上封装成了元组
	def fun5(*a):
    	print(a) #元组

	fun5(10,20,30)
	--------------
	def 函数名(**kwargs)
		将参数封装成了字典
		
	def fun6(**a):
    	print(a)


	fun6(b=10,c=20,d=30)
可变成参数和位置参数混用的时候：
	def fun6(*a,b):
    	print(a,b)
	fun6(10,20,b=30)
	
	def fun6(b,*a):
    	print(a,b)
	fun6(10,20,30)

5、 函数的文档

文档注释：#，三引号
函数的文档注释：
	函数结构的第一行
	
def fun6(b,*a):
    """
    fun6是个函数
    a:可变成参数
    b:位置参数
    """
    print(a,b)

fun6(10,20,30)

print(fun6.__doc__) 
1. 获取函数的文档内容:  函数名.__doc__

2. help(函数名) #查看函数文档

6、 函数的返回值

关键字：return
返回值谁调用就返回给谁

• 任何函数都有返回值

• 如果不写return ，也会默认加一个return None

• 如果写return ，不写返回值 也会默认加一个None

• 可以返回任何数据类型

• return后面的代码不在执行，代表着函数的结束

7、函数的变量的作用域

• 局部变量
  定义在函数内部的变量
  先赋值在使用
  从定义开始到包含他的代码结束
  在外部无法访问

• 全局变量
  定义在源文件的开头
  作用范围：整个文件
  局部变量和全局变量发生命名冲突时，以局部变量优先

• global
  声明全局变量

   def fun1():
       global b
       b=100
       print(b)
   fun1()
   print(b)

• nonlocal
  声明的是局部变量

   def fun1():
            b=100
            def fun2():
                nonlocal b
                b=300
                print(b)
            fun2()
            print(b)
		fun1()

• 函数内部不能进行a+=1,a=a+1这样的操作（全局变量）

解决饭方式1：
			b=100
            def fun1():
                global b
                b = b+1

                print(b)
            fun1()
        解决饭方式2：
         def fun1():
            b=100
            def fun2():
                nonlocal b
                b=b+1
                print(b)
            fun2()
            print(b)
        fun1()

7、内嵌函数

内部函数

内部函数的作用范围：从定义开始到包含给他的代码块结束
在内部函数中不能进行a+=1,a=a+1这样的操作，解决方案是nonlocal

8、 闭包

闭包：是函数式编程的重要语法结构，函数式编程是一种编程范式
编程范式：对代码进行提炼和抽象概括，使得重用性更高

如果内部函数调用了外部函数的局部变量，并外部函数返回内部函数的函数对象（函数名）

   def fun1():
       a=100
       def fun2():
           print(a)
           return "哈哈"
       return fun2
     print(fun1()())   

• 作用：

  可以传递更少的形参，可以传递更多的实参—更加安全

def fun1(b):
        a=100
        print(b)

        def fun2(c):
            print(c)
            return "哈哈"
        return fun2


    print(fun1(200)(300))

间接性的访问内部函数

• 条件

  1. 必须是一个内嵌函数
  2. 外部函数必须返回内部函数的函数对象
  3. 内部函数必须使用外部函数的局部变量

9、lambda表达式

• 匿名函数
  没有名字的函数

• 使用时机：
  只使用一次的时候

• 语法：
  关键字： lambda
  lambda 参数1，参数2:返回值

• lambda的书写形式更加的简洁，优雅

     l = lambda x:x
        print(l(100))

• lambda的优先级最低

---

八、机器人实战

知识点总结完后，就来看看实例。

安装模块（功能）

语法:import 模块名

   pip install itchat #微信功能
		pip install request #发送请求

#导入相关模块，功能
import itchat
import requests

#1.生成机器人进行回复消息

KEY = "a7e21d94d4944e5ca6d4215f46a0339d"

#1. 实现机器人功能
def get_response(msg):
    apiUrl = "http://www.tuling123.com/openapi/api" #要访问的网站
    #key：机器人的key，info是要发送的消息
    data = {'key':KEY,'info':msg,'userid':"WeChat-robot"}
    #发送请求：
    r = requests.post(apiUrl,data=data).json()
    return r["text"]


#第二步：实现微信功能
#装饰器，用于查询哪个好友给你发消息
@itchat.msg_register(itchat.content.TEXT) #好友的信息
def tuling_reply(user_data):
    print(user_data) #用户的信息包含给你发的消息
    user = user_data["Text"] #用户发你的消息
    return_user = get_response(user_data["Text"])
    print(return_user)
    return return_user or user

itchat.auto_login() #扫码登录
itchat.run() #循环执行上面的函数 

我的Python基础知识点就总结到这了，每个人的学习方法和总结方法或许不一样，但是希望我的总结有一定的参考价值，给带来你们一定的帮助!
最后祝愿所有点赞收藏的小伙伴都能顺利通过学习完成人生逆袭。

---

感谢每一位愿意读完我文章的人，对于新媒体创作我也在不断学习中。创作是一件非常值得持续投入的事情，因为你们每一次的支持都是对我极大的肯定！
再次感谢大家的支持，在此我整理了一些适合大多数人学习的资料，免费给大家下载领取!
看！干货在这里↓ ↓ ↓

有需要的读者可以直接拿走，在我的QQ学习交流群。有学习上的疑问、或者代码问题需要解决的，想找到志同道合的伙伴也可以进群，记住哦仅限学习交流！！！
裙号是：298154825。

标签：知识点,下标,函数,10,Python,码住,列表,print,def
来源： https://blog.csdn.net/wuli1024/article/details/118488493