python学习笔记（基础知识大全）

 # 输出你好世界

    
 print("你好世界")
    
    
    
    
    python

 """

    
     我是多行注释
    
     我喜欢一键三连
    
     （doge）
    
 """
    
 print("祝大家：")
    
 print("身体健康")
    
 print("心想事成")
    
    
    
    
    python

 test = "我爱修仙"

    
 print(type(test))
    
 tes = 123456
    
 print(type(tes))
    
 te = True
    
 print(type(te))
    
 print(type(10.15))
    
    
    
    
    python

 # 1.单引号定义法：

    
 name = ' 我爱三连 '
    
  
    
 # 2.双引号定义法：
    
 name = " 我爱三连 "
    
  
    
 # 3.三引号定义法：
    
 name = """ 我爱三连 """
    
    
    
    
    python

 # 1.单引号定义法：

    
 name = ' "我爱三连" '
    
  
    
 # 2.双引号定义法：
    
 name = " '我爱三连' "
    
  
    
 # 3.三引号定义法：
    
 name = """ \"我爱三连\" """
    
    
    
    
    python

 name = '我爱三连'

    
 print("我是逍朽，"+name)
    
    
    
    
    python

 message = '我爱三连'

    
 print("我是逍朽，%s" % message)
    
    
    
    
    python

 message = '我爱三连'

    
 blessing = "祝大家心想事成"
    
 print("我是逍朽，%s,%s" % (message,blessing))
    
    
    
    
    python

 message = '我爱三连'

    
 blessing = "祝大家心想事成"
    
 print(f"我是逍朽,{message},{blessing}")
    
    
    
    
    python

 """

    
 定义如下变量：
    
     name，逍朽
    
     term，爱的期限，比如1万年
    
     index，爱的增长指数，比如5.20
    
     输出：
    
 博主（逍朽）对你们的爱有个期限为1万年。                         本行要求使用f"{变量}"的方式输出
    
 当前爱你们的指数为13.14，每年增长5.2，期限到后，指数达到了           本行要求使用%占位符的方式输出，数据准确到小数点后3位
    
 """
    
 # 定义变量逍朽
    
 name = "逍朽"
    
 # 定义爱的期限为1
    
 term = 1
    
 # 定义爱的增长为5.20
    
 index = 5.20
    
 # 定义当前的指数为13.14
    
 presently = 13.14
    
 #输出第一行
    
  
    
 print(f"博主（{name}对你们的爱有个期限为{term}万年。）")
    
 print("当前爱你们的指数为%.3f，每年增长%.3f，期限到后，指数达到了%.3f"% (presently, index, presently*index**term))
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/z2JnyTHdVbh7alZucwEkgBAioYXG.png)

 print("请输入你的名字：")

    
 name = input()
    
 print(f"我知道了，你的名字是：{name}")
    
  
    
 name = input("请输入你的名字：")
    
 print(f"我知道了，你的名字是：{name}")
    
  
    
 print("请输入你的名字：")
    
 print("我知道了，你的名字是%s" % input())
    
 print(f"我知道了，你的名字是{input()}")
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/qK0RX6n8hNHVlbAf2QBS4tMiwUsa.png)

 #如下所示：

    
 result = 66 > 6
    
 test = ('a' == 'b')
    
 #result的值为真，test的值为假
    
    
    
    
    python

 num = int(input("请输入你的三连次数："))

    
 if num > 0 :
    
     print("感谢你的三连，博主会继续努力的")  #此行代码将在判断为真时输出
    
  
    
 print("祝你心想事成")  #此行代码没有填充4个空格，不属于if判断里面的语句，不管是否为真都会执行
    
    
    
    
    python

 num = int(input("请输入你的三连次数："))

    
 if num > 0 :
    
     print("感谢你的三连，博主会继续努力的")  #此行代码将在判断为真时输出
    
 else:
    
     print("这次一定，好不好，555") #此行代码将在判断为假时输出
    
  
    
 print("祝你心想事成")  #此行代码没有填充4个空格，不属于if判断里面的语句，不管是否为真都会执行
    
    
    
    
    python

 num = int(input("请输入你的三连次数："))

    
 if num > 10 :
    
     print(f"{num}次啊！博主受宠若惊，肥肠感谢你的三连，博主会继续努力的")
    
 elif num > 0:
    
     print("博主肥肠感谢你的三连，窝会继续努力的")
    
 else:
    
     print("这次一定，好不好，555") #此行代码将在判断为假时输出
    
  
    
 print("祝你心想事成")  #此行代码没有填充4个空格，不属于if判断里面的语句，不管是否为真都会执行
    
    
    
    
    python

 age =20

    
 year = 3
    
 level = 1
    
 if age >= 18:
    
     print("你是成年人")
    
     if age< 30:
    
     print("你的年龄达标了")
    
     if year > 2:
    
         print("恭喜你，年龄和入职时间都达标，可以领取礼物")
    
     elif level > 3:
    
         print("恭喜你，年龄和级别大表，可以领取礼物")
    
     else:
    
         print("不好意思，尽管年龄达标，但是入职时间和级别都不达标。")
    
     else:
    
     print("不好意思，年龄太大了")
    
 else:
    
     print("不好意思，小朋友不能领取喔")
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/82uOUr3ZeYRT6tMVbwliq5DX0zxW.png)

 import random  # 导入 Python 内置的 random 模块，用于生成随机数

    
  
    
 num = random.randint(1, 66)  # 使用 random 模块的 randint 方法生成一个 1 到 66 之间（包括 1 和 66）的随机整数，并将其赋值给变量 num
    
    
    
    
    python

 import random  # 导入 Python 内置的 random 模块，用于生成随机数

    
 num = random.randint(1, 66)  # 使用 random 模块的 randint 方法生成一个 1 到 66 之间（包括 1 和 66）的随机整数，并将其赋值给变量 num
    
 guess_num = int(input("请输入你要猜测的数字"))
    
 if guess_num == num :
    
     print("好厉害，第一次就猜中了")
    
 else:
    
     if guess_num < num :
    
     print("你猜测的小啦")
    
     else:
    
     print("你猜测的大啦")
    
  
    
     guess_num = int(input("请输入你要猜测的数字"))
    
  
    
     if guess_num == num :
    
     print("恭喜，第二次就猜对啦")
    
     else:
    
     if guess_num < num :
    
         print("你猜测的小啦")
    
     else:
    
         print("你猜测的大啦")
    
  
    
     guess_num = int(input("请输入你要猜测的数字"))
    
  
    
     if guess_num == num:
    
         print("恭喜，第三次就猜对啦")
    
     else:
    
         if guess_num < num:
    
             print("你猜测的小啦")
    
         else:
    
             print("你猜测的大啦")
    
  
    
         guess_num = int(input("请输入你要猜测的数字"))
    
  
    
         if guess_num == num:
    
             print("恭喜，第四次就猜对啦")
    
         else:
    
             if guess_num < num:
    
                 print("你猜测的小啦")
    
             else:
    
                 print("你猜测的大啦")
    
  
    
             if int(input("请输入你要猜测的数字")) == num:
    
                 print("恭喜，第五次就猜对啦")
    
             else:
    
                 print(f"很遗憾，数字为{num}，你没有猜对")
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/dBkE90R2zUVPQbJ5wclKyt4fsLG3.png)

 i = 0

    
 while i < 100:
    
     print("坤，你太梅")
    
     i+=1        # 没有这行代码，程序会一直输出“坤，你太梅”
    
     # 注意：python里面没有i++这个写法
    
    
    
    
    python

 import random  # 导入 Python 内置的 random 模块，用于生成随机数

    
 num = random.randint(1, 66)  # 使用 random 模块的 randint 方法生成一个 1 到 66 之间（包括 1 和 66）的随机整数，并将其赋值给变量 num
    
 outcome = True
    
 frequency = 0
    
 while outcome :
    
     guess_num = int(input("请输入你要猜的数字"))
    
     if guess_num == num :
    
     print(f"恭喜你第猜对了，一共用了{frequency+1}次")
    
     outcome = False
    
     else:
    
     if guess_num > num :
    
         print("你猜的大啦")
    
     else:
    
         print("你猜的小啦")
    
     frequency = frequency + 1
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/q0GfRmgdD5aE9Svi8rUoCML1W23J.png)

 a = 0

    
 while a < 100:
    
     print(f"今天是第{a+1}天，准备成为真爱粉")
    
     b = 1
    
     while b <= 4:
    
     print(f"练习唱跳rap的第{b}个2.5小时")
    
     b +=1
    
     print("努力成为鸽鸽")
    
     a += 1
    
 print(f"坚持到第{a/4}个2.5天，成为了黑子")
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/6ZrbQhc5GNL0JqeaPIxy8CfzmS2o.png)

 print("Hello", end='')

    
 print("World", end='')
    
    
    
    
    python

 print("Hello World")

    
 print("itheima best")  # 使用空格无法对齐
    
 print("Hello\tWorld")
    
 print("itheima\tbest") # 使用\t后，可以对齐
    
    
    
    
    python

 i = 1  # 初始化变量 i 为 1

    
 while i < 10 :  # 当 i 小于 10 时，执行循环
    
     j = 1  # 每次进入内层循环前，初始化变量 j 为 1
    
     while j <= i :  # 当 j 小于等于 i 时，执行内层循环
    
     print(f"{j} * {i} = {j*i}\t",end='')  # 打印乘法表达式及结果，并使用制表符分隔，且不换行
    
     j += 1  # j 自增 1
    
     print()  # 换行
    
     i += 1  # i 自增 1
    
    
    
    
    python

 #定义字符串name

    
 name = "ikun"
    
 #for循环处理字符串
    
 for x in name:
    
     print(x)
    
    
    
    
    python

 a = 0

    
 for a in range(1,101):
    
     print(f"今天是第{a}天，准备成为真爱粉")
    
     for b in range(1,5):
    
     print(f"练习唱跳rap的第{b}个2.5小时")
    
     print("努力成为鸽鸽")
    
 print(f"坚持到第{a/4}个2.5天，成为了黑子")
    
    
    
    
    python

 #通过外层循环控制行数

    
 for i in range(1,10):
    
     #通过内层循环控制每一行的数据
    
     for j in range(1,i + 1):
    
     #在内层循环中输出每一行的内容
    
       print(f"{j}*{i}={j * i}\t",end='')
    
  
    
     #外层循环可以通过print输出一个回车符
    
     print()
    
    
    
    
    python

 num = 100  # 定义上限值为 100

    
 count = 0  # 初始化偶数计数器为 0
    
 for x in range(1, num):  # 遍历从 1 到 99 的数字
    
     if x % 2 == 0:  # 判断当前数字是否为偶数
    
     count += 1  # 如果是偶数，计数器加 1
    
 print(f"1 到{num}（不含{num}）中有{count} 个偶数")  # 输出偶数的数量
    
    
    
    
    python

 # 定义函数

    
 def add(x,y):
    
     result=x+y
    
     print(f"{x}+{y}的结果是：{result}")
    
  
    
 # 调用函数
    
 add(1,2)
    
    
    
    
    python

 # 定义函数

    
 def add(x,y):
    
     result = x+y
    
     # 返回返回值result
    
     return result
    
  
    
 # 调用函数
    
 num = add(1,2)
    
 # 输出返回值
    
 print(num)
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/jntz4mHQch7KBCV8WLqATrX0pxDy.png)

 # 定义函数

    
 def my_print():
    
     print("击泥胎梅")
    
  
    
 # 调用函数
    
 test = my_print()
    
 # 输出返回值
    
 print(f"返回值为{test}，返回值类型为{type(test)}")
    
    
    
    
    python

 # 定义函数

    
 def your_age(age):
    
     if age >= 18:
    
     return 'SUCCESS'
    
  
    
 # 调用函数，当年龄小于18时，test为None
    
 test = your_age(int(input("请输入你的年龄\n")))
    
 # 当test为None时，not None为真，于是输出语句
    
 if not test:
    
     print("对不起，未满十八岁不能进入")
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/JsL3Gz98MhwkW7Duc5NUOItvX2qo.png)

 # 暂不赋予变量具体值

    
 name = None
    
    
    
    
    python

 #定义函数，进行文档说明

    
 def add(a,b):
    
     """
    
     add函数可以接收2个参数，进行2数相加的功能
    
     :param a: 形参a表示相加的其中一个数字
    
     :param b: 形参b表示相加的另外一个数字
    
     :return: 返回值是2数相加的结果
    
     """
    
     result = a + b
    
     print(f"2数相加的结果是：{result}")
    
     return result
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/tMw9HBavLhzFqEZ34PKGYQrjbcei.png)

 def func_b():

    
     print("---2---")
    
 def func_a():
    
     print("---1---")
    
     func_b()
    
     print("---3---")
    
     # 调用函数func_a
    
 func_a()
    
    
    
    
    python

 def testA():

    
     num = 100
    
     print(num)
    
 testA()   #输出100
    
 print(num)   #报错：name'num'isnot defined
    
    
    
    
    python

 #定义全局变量a

    
 num = 100
    
 def testA():
    
     print(num)#访问全局变量num，并打印变量num存储的数据
    
 def testB():
    
     print(num)#访问全局变量num，并打印变量num存储的数据
    
 testA() # 输出100
    
 testB() # 输出100
    
    
    
    
    python

 #定义全局变量a

    
 num = 100
    
 def testA():
    
     print(num)#访问全局变量num，并打印变量num存储的数据
    
 def testB():
    
     num = 200
    
     print(num)#访问全局变量num，并打印变量num存储的数据
    
 testA() # 输出100
    
 testB() # 输出100
    
 print(num)
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/OLHCmn8iTMZP31olDSr0bq6WFBdu.png)

 #定义全局变量a

    
 num = 100
    
 def testA():
    
     print(num)#访问全局变量num，并打印变量num存储的数据
    
 def testB():
    
     global num
    
     num = 200
    
     print(num)#访问全局变量num，并打印变量num存储的数据
    
 testA() # 输出100
    
 testB() # 输出100
    
 print(num)
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/icvWjbEI97fHxwFUz8tZGMOSKDBy.png)

 #定义一个列表list

    
 my_list = ["itheima","itcast","python"]
    
 print(my_list)
    
 print(type(my_list))
    
  
    
 my_list = ["itheima", 666, True]
    
 print(my_list)
    
 print(type(my_list))
    
  
    
 #定义一个嵌套的列表
    
 my_list = [[1, 2, 3],[4,5,6]]
    
 print(my_list)
    
 print(type(my_list))
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/DgCGIlOjh4NnTsB6cyV1bPSJMRXu.png)

 #语法：列表[下标索引]

    
 name_list = ['Tom','Lily','Rose']
    
 print(name_list[0])#结果：Tom
    
 print(name_list[1])#结果：Lily
    
 print(name_list[2])#结果：Rose
    
    
    
    
    python

 #语法：列表[下标索引]

    
 name_list = ['Tom','Lily','Rose']
    
 print(name_list[-3])#结果：Tom
    
 print(name_list[-2])#结果：Lily
    
 print(name_list[-1])#结果：Rose
    
    
    
    
    python

 #函数

    
 def add(x,y):
    
     return x+y
    
 #函数的使用
    
 num = add(1,2)
    
  
    
 #方法
    
 class Student:
    
     def add(self,x,y):
    
     return x+y
    
 #方法的使用:
    
 student = Student()
    
 num = student.add(1,2)
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/me1aJXH9l8cKijwduRyqbWC6Qv7s.png)

 mylist = ["ikun","geigei","lizhi"]

    
 # 查找某元素在列表内的下标索引
    
 index = mylist.index("ikun")
    
 print(f"ikun在列表中的下标索引值是：{index}")
    
 #如果被查找的元素不存在，会报错
    
 index = mylist.index("hello")
    
 print(f"hello在列表中的下标索引值是：{index}")
    
  
    
    
    
    
    python

 #正向下标

    
 my_list = [1, 2, 3]
    
 my_list[0] = 5
    
 print(my_list) # 结果：[5，2，3]
    
 # #反向下标
    
 my_list = [1, 2, 3]
    
 my_list[-3] = 5
    
 print(my_list) # 结果： [5，2，3]
    
    
    
    
    python

 my_list =[1,2,3]

    
 my_list.insert(1, "ikun")
    
 print(my_list) #结果：：[1，"ikun"，3，4]
    
    
    
    
    python

 my_list =[1,2,3]

    
 my_list.append(4)
    
 print(my_list) # 结果：[1，2，3, 4]
    
    
    
    
    python

 my_list = [1,2,3]

    
 my_list.extend([4,5,6])
    
 print(my_list) # 结果：[1,2,3,4,5,6]
    
    
    
    
    python

 my_list =[1,2,3]

    
 del my_list[0]
    
 print(my_list) # 结果：[2,3]
    
  
    
 num = my_list.pop(0)
    
 print(num) # 结果：1
    
 print(my_list) # 结果：[2,3]
    
    
    
    
    python

 my_list=[1,2,3,2,3]

    
 my_list.remove(2)
    
 print(my_list)#结果：[1，3，2，3]
    
    
    
    
    python

 my_list =[1,2,3]

    
 my_list.clear()
    
 print(my_list)#结果：[]
    
    
    
    
    python

 my_1ist=[1,1,1,2,3]

    
 print(my_1ist.count(1)) #结果：3
    
    
    
    
    python

 my_1ist=[1,1,1,2,3]

    
 print(len(my_1ist)) # 结果：5
    
    
    
    
    python

 my_1ist=[1,1,1,2,3]

    
 # 定义一个变量来标记列表的下标
    
 index = 0   # 初始值为0
    
 print(my_1ist)
    
 # 通过len（）获取列表长度作为判断条件，这里需要注意因为下标是从0开始，所以遍历5个元素的列表，下标只需要到4就可以了，所以判断条件不需要<=
    
 while index < len(my_1ist):
    
     print(f"元组第{index+1}个元素是{my_1ist[index]}")
    
     # 将循环变量（index）每一次循环都+1，缺少的话会导致死循环
    
     index += 1
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/eDlbIdRNqsny7Hgu5iBcKtMXhmpP.png)

 my_1ist=[1,1,1,2,3]

    
 print(my_1ist)
    
 for i in my_1ist:
    
     print(f"元组元素有：{i}")
    
    
    
    
    python

 # 定义一个元素的元组

    
 t2 =('Hello',) # 注意必须带有逗号，否则不是元组类型
    
    
    
    
    python

 #定义一个嵌套元组

    
 t1 =((1,2,3),(4,5,6))
    
 print(t1[0][0]) # 结果：1
    
    
    
    
    python

 #尝试修改元组内容

    
 t1 = (1,2,['ikun','geigei'])
    
 t1[2][1] = 'best'
    
 print(t1) # 结果：(1，2，['ikun'，‘best'])
    
    
    
    
    python

 #根据下标（索引）取出数据

    
 t1=(1,2,'he1lo')
    
 print(t1[2]) # 结果：‘hello’
    
  
    
 # 根据index（），查找特定元素的第一个匹配项
    
 tl = (1,2,"hello",3,4,'hello')
    
 print(tl.index('hello')) # 结果：2
    
  
    
 # 统计某个数据在元组内出现的次数
    
 t2 = (1,2,'hello',3,4,"hello")
    
 print(t2.count("hello")) # 结果：2
    
  
    
 # 统计元组内的元素个数
    
 t3 = (1, 2, 3)
    
 print(len(t3)) # 结果3
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/CI1PRvYurJixStEAwWcjkgdoGKnb.png)

 #通过下标获取特定位置字符

    
 name ="ikun"
    
 print(name[0]) # 结果 i
    
 print(name[-1]) # 结果 n
    
    
    
    
    python

  
    
 str = "ikun and geigei"
    
 print(str.index("and")) # 结果5
    
    
    
    
    python

 str = "ikun and geigei"

    
 re_str = str.replace("and", "和")
    
 print(re_str)   # 结果为ikun 和 geigei
    
    
    
    
    python

 str = "ikun and geigei"

    
 str_list = str.split(" ")
    
 print(str_list)   # 结果为['ikun', 'and', 'geigei']
    
    
    
    
    python

  
    
 str = "   12ikun and geigei21   "
    
 strip_str = str.strip()
    
 print(strip_str)   # 结果为12ikun and geigei21
    
 strip_str2 = strip_str.strip("12")
    
 print(strip_str2)   # 结果为ikun and geigei
    
    
    
    
    python

 str = "ikun and geigei"

    
 count = str.count("i")
    
 print(count) # 结果为3
    
    
    
    
    python

 str = "ikun and geigei"

    
 num = len(str)
    
 print(num) # 结果为15
    
    
    
    
    python

 # 对List进行切片，从1开始，4结束，步长1

    
 my_list = [0, 1, 2, 3, 4, 5, 6]
    
 result1 = my_list[1:4]  # 步长默认是1，所以可以省略不写
    
 print(f"结果1:{result1}") # 结果1:[1, 2, 3]
    
  
    
 # 对tupLe进行切片，从头开始，到最后结束，步长1
    
 my_tuple = (0, 1, 2, 3, 4, 5, 6)
    
 result2 = my_tuple[:]   # 起始和结束不写表示从头到尾，步长为1可以省略
    
 print(f"结果2:{result2}") # 结果2:(0, 1, 2, 3, 4, 5, 6)
    
  
    
 # 对str进行切片，从头开始，到最后结束，步长2
    
 my_str = "01234567"
    
 result3 = my_str[::2]
    
 print(f"结果3：{result3}") # 结果3：0246
    
  
    
 #对str进行切片，从头开始，到最后结束，步长-1
    
 my_str = "01234567"
    
 result4 = my_str[::-1]  # 等同于将序列反转了
    
 print(f"结果4:{result4}") # 结果4:76543210
    
  
    
 #对列表进行切片，从3开始，到1结束，步长-1
    
 my_list = [0, 1, 2, 3, 4, 5, 6]
    
 result5 = my_list[3:1:-1]
    
 print(f"结果5：{result5}") # 结果5：[3, 2]
    
  
    
 #对元组进行切片，从头开始，到尾结束，步长-2
    
 my_tuple = (0, 1, 2, 3, 4, 5, 6)
    
 result6 = my_tuple[::-2]
    
 print(f"结果6:{result6}") # 结果6:(6, 4, 2, 0)
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/ItRwbosxJjLdCUTnZzO7401XaNrk.png)

 my_set = {"ikun", "and", "geigei"}

    
 my_set.add("lizhi")
    
 print(my_set) # 结果{'lizhi', 'geigei', 'and', 'ikun'}
    
    
    
    
    python

 my_set = {"ikun", "and", "geigei"}

    
 my_set.remove("and")
    
 print(my_set) # 结果{'ikun', 'geigei'}
    
    
    
    
    python

 my_set = {"ikun", "and", "geigei"}

    
 element = my_set.pop()
    
 print(element) # 结果ikun
    
 print(my_set) # 结果{'and', 'geigei'}
    
    
    
    
    python

 my_set = {"ikun", "and", "geigei"}

    
 my_set.clear()
    
 print(my_set) # 结果set()
    
    
    
    
    python

 set1 = {1, 2, 3}

    
 set2 = {1, 5, 6}
    
 set3 = set1.difference(set2)
    
 print(set3)  # 结果：{2，3}  得到的新集合
    
 print(set1)  # 结果：{1，2，3} 不变
    
 print(set2)  # 结果：{1，5，6} 不变
    
    
    
    
    python

 set1 = {1, 2, 3}

    
 set2 = {1, 5, 6}
    
 set1.difference_update(set2)
    
 print(set1)  # 结果：{2，3}
    
 print(set2)  # 结果：{1，5，6} 
    
    
    
    
    python

 set1 = {1, 2, 3}

    
 set2 = {1, 5, 6}
    
 set3 = set1.union(set2)
    
 print(set3) # 结果：{1，2，3，5，6}，新集合
    
 print(set1) # 结果：{1，2，3}，set1不变
    
 print(set2) # 结果：{1，5，6}，set2不变
    
    
    
    
    python

 #统计集合元素数量len（）

    
 set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
    
 num = len(set1)
    
 print(num) # 结果：5
    
    
    
    
    python

 #语法，字典[Key]可以取到对应的value

    
 stu_score ={"ikun":99, "geigei":88}
    
 print(stu_score["ikun"]) # 结果99
    
 print(stu_score["geigei"]) # 结果88
    
    
    
    
    python

 #语法，字典[Key]可以取到对应的value

    
 stu_score ={"ikun":{"语文":99, "数学":66}, "geigei":{"语文":88,"数学":77}}
    
 print(stu_score["ikun"]["语文"]) # 结果99
    
 print(stu_score["geigei"]["数学"]) # 结果77
    
    
    
    
    python

 stu_score ={"ikun":99, "geigei":88}

    
 # 新增，lizhi的分数
    
 stu_score["lizhi"]=77
    
 print(stu_score) # 结果：{'ikun': 99, 'geigei': 88, 'lizhi': 77}
    
    
    
    
    python

 stu_score ={"ikun":99, "geigei":88}

    
 # 修改元素
    
 stu_score["ikun"]=25
    
 print(stu_score) # 结果：{'ikun': 25, 'geigei': 88}
    
    
    
    
    python

 stu_score ={"ikun":99, "geigei":88}

    
 # 删除对应元素
    
 value = stu_score.pop("ikun")
    
 print(value) # 结果：99
    
 print(stu_score) # 结果：{'geigei': 88}
    
    
    
    
    python

 stu_score ={"ikun":99, "geigei":88}

    
 # 清空字典
    
 stu_score.clear()
    
 print(stu_score) # 结果：{}
    
    
    
    
    python

 stu_score ={"ikun":99, "geigei":88}

    
 # 获取字典的全部Key，可用于for循环遍历字典
    
 keys = stu_score.keys()
    
 print(keys) # 结果：dict_keys(['ikun', 'geigei'])
    
    
    
    
    python

 stu_score ={"ikun":99, "geigei":88}

    
 # 计算字典内的元素数量
    
 num = len(stu_score)
    
 print(num) # 结果：2
    
    
    
    
    python

 my_list = [1, 2, 3]

    
 my_tuple =(1,2,3, 4, 5)
    
 my_str = "ikun"
    
 print(len(my_list)) # 结果3
    
 print(len(my_tuple)) # 结果5
    
 print(len(my_str)) # 结果4
    
    
    
    
    python

 my_list = [1, 2, 3]

    
 my_tuple =(1,2,3, 4, 5)
    
 my_str = "ikun"
    
 print(max(my_list)) # 结果3
    
 print(max(my_str)) # 结果u
    
 print(max(my_tuple)) # 结果5
    
    
    
    
    python

 my_list = [1, 2, 3]

    
 my_tuple =(1,2,3, 4, 5)
    
 my_str = "ikun"
    
 print(min(my_list)) # 结果1
    
 print(min(my_str)) # 结果i
    
 print(min(my_tuple)) # 结果1
    
    
    
    
    python

 # 如下嵌套列表，要求对外层列表进行排序，排序的依据是内层列表的第二个元素数字

    
 # 以前学习的sorted函数就无法适用了。可以使用列表的sort方法
    
 my_list =[["a",33],["b",55],["c",11]]
    
 #定义排序方法
    
 def choose_sort_key(element):
    
     return element[1]
    
 #将元素传入choose_sort_key函数中，用来确定按照谁来排序
    
 my_list.sort(key=choose_sort_key,reverse=True)
    
 print(my_list)
    
    
    
    
    python

 # 如下嵌套列表，要求对外层列表进行排序，排序的依据是内层列表的第二个元素数字

    
 my_list=[["a",33],["b",55],["c",11]]
    
 my_list.sort(key=lambda element:element[1],reverse=True)
    
 print(my_list)
    
    
    
    
    python

 #演示使用多个变量，接收多个返回值

    
 def test_return():
    
     return 1,"ikun",True
    
 x,y,z=test_return()
    
 print(x)    # 结果：1
    
 print(y)    # 结果：ikun
    
 print(z)    # 结果：True
    
    
    
    
    python

 def user_info(name, age, gender):

    
     print(f"您的名字是{name}，年龄是{age}，性别是{gender}")
    
  
    
 user_info('ikun',2.5,'man')
    
 # 输出结果为：您的名字是ikun，年龄是2.5，性别是man
    
    
    
    
    python

 def user_info(name, age, gender):

    
     print(f"您的名字是{name}，年龄是{age}，性别是{gender}")
    
  
    
 # 关键字传参
    
 user_info(name='ikun',age=2.5,gender='man')
    
 # 可以不按照固定顺序
    
 user_info(age=2.5,gender='man',name='ikun')
    
 # 可以和位置参数混用，位置参数必须在前，且匹配参数顺序
    
 user_info('ikun',age=2.5,gender='man')
    
 # 上述的输出均是：您的名字是ikun，年龄是2.5，性别是man
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/HNc4tEzJ0KyBLrwWOniqd593YDFh.png)

 def user_info(name, age, gender='man'):

    
     print(f"您的名字是{name}，年龄是{age}，性别是{gender}")
    
  
    
 user_info('ikun',2.5)   # 您的名字是ikun，年龄是2.5，性别是man
    
 user_info('geigei',2.5,'woman') # 结果：您的名字是geigei，年龄是2.5，性别是woman
    
    
    
    
    python

 def user_info(**kwargs):

    
     print(kwargs)
    
  
    
 user_info(name='ikun',age=2.5,id=666) # 结果为：{'name':'ikun','age':2.5,'id':666}
    
    
    
    
    python

 def user_info(*args):

    
     print(args)
    
  
    
 user_info('ikun') # 结果为：('ikun',)
    
 user_info('ikun',2.5) # 结果为：('ikun', 2.5)
    
    
    
    
    python

 #定义一个函数，接受其它函数输入

    
 def test_func(compute):
    
     result = compute(1,2)
    
     print(f"结果是:{result}")
    
 # 通过Lambda匿名函数的形式，将匿名函数作为参数传入
    
 test_func(lambda x, y: x + y)
    
    
    
    
    python

 f = open('python.txt', 'r', encoding=" UTF-8 ")

    
 #encoding的顺序不是第三位，所以不能用位置参数，用关键字参数直接指定
    
    
    
    
    python

 for line in open("python.text","r"):

    
     print(line)
    
 # 每一个line临时变量，就记录了文件的一行数据
    
    
    
    
    python

 # 打开文件

    
 f = open("ikun.txt", 'w', encoding='utf-8')
    
 # 文件写入
    
 f.write("geigei")
    
 # 内容刷新
    
 f.flush()
    
 # 文件关闭
    
 f.close()
    
    
    
    
    python

 # 打开文件

    
 f = open("ikun.txt", 'a', encoding='utf-8')
    
 # 文件写入
    
 f.write("2.5")
    
 # 内容刷新
    
 f.flush()
    
 # 文件关闭
    
 f.close()
    
    
    
    
    python

 try :

    
     print(name)
    
 except:
    
     print("出现异常啦")
    
    
    
    
    python

 try :

    
     print(name)
    
 except NameError as e:
    
     print("出现异常啦\n", e)
    
    
    
    
    python

 try :

    
     print(name)
    
 except (NameError, ZeroDivisionError) as e:
    
     print("出现异常啦\n", e)
    
    
    
    
    python

 try :

    
     print(name)
    
 except (NameError, ZeroDivisionError) as e:
    
     print("出现异常啦\n", e)
    
 else:
    
     print("没有异常我会执行")
    
    
    
    
    python

 try :

    
     print(name)
    
 except (NameError, ZeroDivisionError) as e:
    
     print("出现异常啦\n", e)
    
 else:
    
     print("没有异常我会执行")
    
 finally:
    
     print("不管有没有异常，我都会执行")
    
    
    
    
    python

 #导入时间模块

    
 import time
    
 print('开始')
    
 # 让程序睡眠1喵
    
 time.sleep(1)
    
 print('结束')
    
    
    
    
    python

 from time import sleep

    
 print('开始')
    
 # 让程序睡觉一秒
    
 sleep(1)
    
 print('结束')
    
    
    
    
    python

 from time import *

    
 print('开始')
    
 # 让程序睡觉一秒
    
 sleep(1)
    
 print('结束')
    
    
    
    
    python

 # 模块别名

    
 import time as tt
    
 tt.sleep(5)
    
 print(123)
    
    
    
    
    python

 # 模块别名

    
 from time import sleep as sl
    
 sl(5)
    
 print(123)
    
    
    
    
    python

 def test(a,b):

    
     print(a+b)
    
 if __name__ == '__main__':
    
     test(3,4)
    
    
    
    
    python

 # 导入json模块

    
 import json
    
 # 准备复合格式json格式要求的python数据
    
 data = [{"name":"ikun","age":2.5},{"name":"geigei","age":3.5}]
    
 # 通过json.dumps（data）方法把python数据转换为了json数据
    
 data1 = json.dumps(data)
    
 # 通过json.loads（data）方法把json数据转化为了python数据
    
 data2 = json.loads(data1)
    
    
    
    
    python

 class student:

    
     name = None    #记录学生姓名
    
    
    
    
    python

 # 基于类创建对象

    
 stu1 = student()
    
 stu2 = student()
    
    
    
    
    python

 stu1.name = 'ikun'      # 为学生1对象赋予属性值

    
 stu2.name = 'geigei'    # 为学生2对象赋予属性值
    
    
    
    
    python

 class student:

    
     name = None    # 记录学生姓名
    
     def say_hi(self, msg):
    
     print(msg)
    
     def say_name(self):
    
     print(self.name)
    
 # 基于类创建对象
    
 stu1 = student()
    
 stu1.name = 'ikun'      # 为学生1对象赋予属性值
    
 stu1.say_hi('hi')       #调用的时候需要传入msg参数
    
 stu1.say_name()         #调用的时候无需传参
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/OEp2gkU48xvDGBimoKQr7TFdSYXu.png)

 class student:

    
     name = None    # 记录学生姓名
    
     age = None     # 记录学生年龄
    
     def __init__(self, name, age):
    
     self.name = name
    
     self.age = age
    
     print("创建了一个对象")
    
 # 基于类创建对象
    
 stu = student('ikun',2.5) # 输出:创建了一个对象
    
 print(stu.name)                     # 输出：ikun
    
 print(stu.age)                      # 输出：2.5
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/fqWsr4Eh9H7AzIBwO2lFMgZeoyp0.png)

 class student:

    
     def __init__(self, name, age):
    
     self.name = name
    
     self.age = age
    
     print("创建了一个对象")
    
 # 基于类创建对象
    
 stu = student('ikun',2.5) # 输出:创建了一个对象
    
 print(stu.name)                     # 输出：ikun
    
 print(stu.age)                      # 输出：2.5
    
    
    
    
    python

 class student:

    
     def __init__(self, name, age):
    
     self.name = name
    
     self.age = age
    
 # 基于类创建对象
    
 stu = student('ikun',2.5) # 输出:创建了一个对象
    
 print(stu)          # 输出：<__main__.student object at 0x000002A9F0C64230>
    
 print(str(stu))     # 输出：<__main__.student object at 0x000002A9F0C64230>
    
    
    
    
    python

 class student:

    
     def __init__(self, name, age):
    
     self.name = name
    
     self.age = age
    
     def __str__(self):
    
     return f'{self.name} is {self.age}'
    
 # 基于类创建对象
    
 stu = student('ikun',2.5) # 输出:创建了一个对象
    
 print(stu)          # 输出：ikun is 2.5
    
 print(str(stu))     # 输出：ikun is 2.5
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/u6R9jcxWwdslUyCNEatGYhAzOveK.png)

 class student:

    
     def __init__(self, name, age):
    
     self.name = name
    
     self.age = age
    
     def __lt__(self, other):
    
     return self.age < other.age
    
 # 基于类创建对象
    
 stu = student('ikun',2.5) # 输出:创建了一个对象
    
 stu1 = student('geigei',25) # 输出:创建了一个对象
    
 print(stu < stu1) # 结果：True
    
 print(stu > stu1) # 结果：False
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/JpBYc9vCoweVQO4lAMP0TjSdF1ua.png)

 class student:

    
     def __init__(self, name, age):
    
     self.name = name
    
     self.age = age
    
     def __eq__(self, other):
    
     return self.age == other.age
    
 # 基于类创建对象
    
 stu = student('ikun',2.5) # 输出:创建了一个对象
    
 stu1 = student('geigei',25) # 输出:创建了一个对象
    
 print(stu == stu1) # 结果：False
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/j9qzwXTxCAirv4JWY68N3QPGVlbd.png)

 class student:

    
     def __init__(self, name, age):
    
     self.name = name
    
     self.age = age
    
     def __le__(self, other):
    
     return self.age <= other.age
    
 # 基于类创建对象
    
 stu = student('ikun',2.5) # 输出:创建了一个对象
    
 stu1 = student('geigei',25) # 输出:创建了一个对象
    
 print(stu <= stu1) # 结果：True
    
 print(stu >= stu1) # 结果：False
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/eJXDOylwiTaLd9A4CQqo7rhBKbtE.png)

 class ji:

    
     IMEI = None         # 序列号
    
     producer = "ikun"   # 厂商
    
     
    
     def call_by_egg(self):
    
     print("geigei")
    
     
    
 class iji(ji):
    
     producer = "IT"             # 复写父类属性
    
     
    
     def call_by_egg(self):      # 复写父类方法
    
     print("geigei的蛋")
    
  
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/29fgoYG1ANLFKq6WuVtsbOBzUl3r.png)

 class ji:

    
     IMEI = None         # 序列号
    
     producer = "ikun"   # 厂商
    
  
    
     def call_by_egg(self):
    
     print("geigei")
    
     return None
    
  
    
 class iji(ji):
    
     producer = "IT"             # 复写父类属性
    
  
    
     def call_by_egg(self):      # 复写父类方法
    
     # 方式1调用父类成员
    
     ji.call_by_egg(self)
    
     # 方式2调用父类成员
    
     super().call_by_egg()
    
     return None
    
  
    
 j = iji()
    
 j.call_by_egg() # 输出俩个geigei
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/Eq5XQsIo1F7SRkhzZctU8lWMA0np.png)

 # 基础数据类型注解

    
 var1: int = 10
    
 var2: float = 2.5
    
 var3: bool = True
    
 var4: str = "ikun"
    
 # 类对象类型注解
    
 class student:
    
     pass
    
 stu: student = student()
    
 # 基础容器类型注解
    
 my_list: list = [1, 2, 3]
    
 my_tuple: tuple = (1, 2, 3)
    
 my_set: set = {1, 2, 3}
    
 my_dict: dict = {"ikun": 2.5}
    
 my_str: str = 'ikun'
    
 # 容器类型详细注解
    
 my_list1: list[int] = [1, 2, 3]
    
 my_tuple1: tuple[str, int, bool] = ('ikun', 2, True)
    
 my_set1: set[int] = {1, 2, 3}
    
 my_dict1: dict[str, float] = {'ikun': 2.5}
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/ZC9MUeGRgSY1mbsFpvN6EKjA3VB5.png)

 # 除了使用变量：类型，这种语法做注解外，也可以在解释中进行类型注解。

    
 import json
    
 from random import random
    
 from _ctypes_test import func
    
 class student:
    
     pass
    
 var1 = random.randint(1,10)  # type:int
    
 var2 = json.loads(data)      # type:dict[str,int]
    
 var3 = func()                # type:student
    
    
    
    
    python

 def test(x:int,y:int):

    
     return x+y
    
    
    
    
    python

 def test(x:int,y:int) -> int:

    
     return x+y
    
    
    
    
    python

 from typing import Union

    
 my_list: list[Union[int, str]] = [1, 2, 'hello', 'world']
    
 my_dict: dict[str,Union[int, str]] = {'name': 'ikun', 'age': 23}
    
  
    
 def func(data: Union[int, str]) -> Union[int, str]:
    
     pass
    
    
    
    
    python

 # 定义父类

    
 class animal:
    
     def speak(self):
    
     pass
    
 #子类继承
    
 class dog(animal):
    
     def speak(self):
    
     print("汪汪汪")
    
 #子类继承
    
 class cat(animal):
    
     def speak(self):
    
     print("喵喵喵")
    
 def main(animal):
    
     animal.speak()
    
 dog = dog()
    
 cat = cat()
    
 main(dog)
    
 main(cat)
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/8fwl5FsvauOBqMTRpd4yPiVt10Ez.png)

    pip install pymysql

 from pymysql import Connection

    
 # 获取到MySQL数据库的链接对象
    
 coon = Connection(
    
     host = 'localhost', # 主机名（或者IP地址）
    
     port = 3306, # 端口，MySQL默认为3306
    
     user = 'root', # 账户名
    
     password = '123456' # 密码
    
 )
    
 # 打印MySQL数据库软件信息
    
 print(coon.get_server_info())  # 当输出你数据库的相关版本时则证明已经成功链接了
    
 # 关闭数据库的链接
    
 coon.close()
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/20fNVUwWdes1Zmt3ibhY8MxoyCqX.png)

 from pymysql import Connection

    
 # 获取到MySQL数据库的链接对象
    
 coon = Connection(
    
     host = 'localhost', # 主机名（或者IP地址）
    
     port = 3306, # 端口，MySQL默认为3306
    
     user = 'root', # 账户名
    
     password = '123456' # 密码
    
 )
    
 # 获取游标对象
    
 cursor = coon.cursor()
    
 coon.select_db('aaa')  # 选择数据库，如果没有aaa则需要提前创建一个
    
 # 使用游标对象，执行sql语句
    
 cursor.execute('CREATE TABLE test(ID INT, INFO VARCHAR(255))')
    
 #关闭数据库的链接
    
 coon.close()
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/ZjaAWIBiwgqhstzJkonOLy0K5cUd.png)

 from pymysql import Connection

    
 # 获取到MySQL数据库的链接对象
    
 coon = Connection(
    
     host = 'localhost', # 主机名（或者IP地址）
    
     port = 3306, # 端口，MySQL默认为3306
    
     user = 'root', # 账户名
    
     password = '123456' # 密码
    
 )
    
 # 获取游标对象
    
 cursor = coon.cursor()
    
 coon.select_db('TEST02')  # 选择数据库，如果没有aaa则需要提前创建一个
    
 # 使用游标对象，执行sql语句
    
 cursor.execute('SELECT * FROM ACCOUNT')
    
 result:tuple = cursor.fetchall()   # 会以元组的形式输出
    
 for row in result:
    
     print(row)
    
 #关闭数据库的链接
    
 coon.close()
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/jd6FL7JC4tcVXTSIPlqgxQybBoZ3.png)

 from pymysql import Connection

    
 # 获取到MySQL数据库的链接对象
    
 coon = Connection(
    
     host = 'localhost', # 主机名（或者IP地址）
    
     port = 3306, # 端口，MySQL默认为3306
    
     user = 'root', # 账户名
    
     password = '123456' # 密码
    
 )
    
 # 获取游标对象
    
 cursor = coon.cursor()
    
 coon.select_db('TEST02')  # 选择数据库，如果没有aaa则需要提前创建一个
    
 # 使用游标对象，执行sql语句
    
 cursor.execute('insert into classes values (999,2021,"计算机科学","20班")')
    
 # 通过commit确认
    
 coon.commit()
    
 # 关闭连接
    
 coon.close()
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-13/ySXcNdqIHlhsZx2fMCgQji4wutO9.png)

 # 获取到MySQL数据库的链接对象

    
 coon = Connection(
    
     host = 'localhost', # 主机名（或者IP地址）
    
     port = 3306, # 端口，MySQL默认为3306
    
     user = 'root', # 账户名
    
     password = '123456', # 密码
    
     autocommit = True # 设置自动提交
    
 )
    
    
    
    
    python