[开发工具]Python笔记

本文作者：林箖霖😉
本文原创，未经允许，禁止转载！

Python的输入输出函数

输入函数

1. 输入函数从键盘接收到的是字符类型（str）

   a = input("输入第一个数：")  # 输入第一个数：10
   b = input("输入第二个数：")  # 输入第二个数：20
   print(a + b)  # 输出结果为：1020这里的'+'是两个字符串的连接符
   print(int(a) + int(b))  # 输出结果为：30，这里要对从键盘接收到的数据进行类型转换才可以进行运算
   

输出函数

指定对齐方式

• 对于整数，指定左对齐时，在右边补 0 是没有效果的，因为这样会改变整数的值。
• 对于小数，以上三个标志可以同时存在。
• 对于字符串，只能使用 ’ - ’ 标志，因为符号对于字符串没有意义，而补 0 会改变字符串的值。

应用举例：

print("hello world")
print('hello world')

# 指定最小输出宽度
n = 1234567
str = 'ling'
# %10d 表示输出的整数宽度至少为 10；
# %20s 表示输出的字符串宽度至少为 20。
print("%10d" % n)  # 00001234567（此处把0当作空格）
print("%7s" % str)  # 0000ling（此处把0当作空格）

# 指定小数精度
f = 3.141592653
# 最小宽度为8，小数点后保留3位
print("%8.3f" % f)  # 3.142
# 最小宽度为8，小数点后保留3位，左边补0
print("%08.3f" % f)  # 0003.142
# 最小宽度为8，小数点后保留3位，左边补0，带符号
print("%+08.3f" % f)  # +003.142

# 指定对齐方式
n = 123456
# %09d 表示最小宽度为9，左边补0
print("%09d" % n)  # 000123456
# %+9d 表示最小宽度为9，带上符号
print("%+9d" % n)  #000+123456 （此处0为空格）
f = 140.5
# %-+010f 表示最小宽度为10，左对齐，带上符号
print("%-+010f" % f)  # +140.500000 （左对齐往右边补0）
s = "Hello"
# %-10s 表示最小宽度为10，左对齐
print("%-10s." % s)  # Hello     .（左对齐往右边补空格）

Python中的注释及转义字符

注释的使用方法

1. 单行注释用符号 ’ # ’
2. 多行注释用三引号 （ ’ ’ ’ 注释内容 ‘ ’ ‘ ）( " " " 注释内容 " " " )

# 单行注释
'''
多行注释
注释内容
'''

"""
多行注释
注释内容
"""

转义字符

应用举例：

print("hello\b")  #hell
print("hello\r")
print("hello\
world")  #helloworld
print("hello\tworld")  #hello   world 其中hell占了四个位置，则\t表示o和三个空格
print("hellooo\tworld")#hellooo world 这个\t表示的是ooo和一个空格
print("\\\'\"")  #\'"

Python中的数据类型及转换

1. 在Python中，数据类型分为整型（int）、浮点型（float）、字符型（str）、布尔型（bool）
2. 在Python中的变量赋值不需要先声明数据类型

字符类型赋值方法

# 可以使用单引号，也可以使用双引号
str1 = 'abc'
str2 = "abcd"
print(str1, type(str1), str2, type(str2))  # abc <class 'str'> abcd <class 'str'>

整型赋值方法

# 赋值运算符
c = 10     # 十进制
e = 0b100  # 二进制
f = 0o100  # 八进制
g = 0x100  # 十六进制
print(c, e, f, g)  # 10 4 64 256

数据类型转换

布尔型（bool）转其他类型

1. 布尔型（bool）中，True代表int类型中的 1 ，False代表int类型中的 0

   a = True
   b = False
   # bool转int
   a = int(a)
   b = int(b)
   print(a, type(a), b, type(b))  # 1 <class 'int'> 0 <class 'int'>
   # bool转str
   a = str(a)
   b = str(b)
   print(a, type(a), b, type(b))  # 1 <class 'str'> 0 <class 'str'>
   # bool转float
   a = float(a)
   b = float(b)
   print(a, type(a), b, type(b))  # 1.0 <class 'float'> 0.0 <class 'float'>
   

其他类型转字符型（str）

1. 所有类型都可以转化为str类型，通常使用str（）函数，或者可以通过直接加 ’ ’ 的方法

   # 其他类型可以无条件转化为str类型
   c = 123
   d = 123.3
   e = True
   print(str(c), type(str(c)), str(d), type(str(d)))  # 123 <class 'str'> 123.3 <class 'str'>
   print(str(e), type(str(e)))  # True <class 'str'>
   # 也可以通过直接加''转化，这个方法类似于定义字符串
   f = '1234'
   print(f, type(f))  # 1234 <class 'str'>
   

其他类型转整型（int）

1. 文字类和小数类字符型（str）无法转化为整型（int）

   # str类型转化为int类型
   str1 = '123'
   str2 = '123.3'
   str3 = '张三'
   print(int(str1), type(int(str1)))  # 123 <class 'int'>
   print(int(str2), type(int(str2)))  # ValueError: invalid literal for int() with base 10: '123.3'
   print(int(str3), type(int(str3)))  # ValueError: invalid literal for int() with base 10: '张三'
   

2. 浮点型（float）转化为整型（int）的时候，小数位会被抹掉

   # float类型转化为int类型
   f1 = 123.33
   f2 = 55.0
   print(int(f1), type(int(f1)))  # 123 <class 'int'>
   print(int(f2), type(int(f2)))  # 55 <class 'int'>
   

其他类型转浮点型（float）

1. 文字类字符串无法转化为float类型

   # str类型转flaot类型
   str4 = '123'
   str5 = '123.4'
   str6 = 'zhang'
   print(float(str4), type(float(str4)))  # 123.0 <class 'float'>
   print(float(str5), type(float(str5)))  # 123.4 <class 'float'>
   print(float(str6), type(float(str6)))  # ValueError: could not convert string to float: 'zhang'
   

2. 整型（int）转化为浮点型（float）会在其末尾加上 ’ .0 ’

   # int类型转float类型
   a = 2
   b = 10
   print(float(a), type(float(a)))  # 2.0 <class 'float'>
   print(float(b), type(float(b)))  # 10.0 <class 'float'>
   

Python中的运算符

算术运算符

加法、减法、乘法

1. 浮点数存储不确定性

   • 使用浮点数进行计算时，可能会出现小数位数不确定的情况

     # 加法、减法、乘法
     # 加法
     print(1 + 1)  # 结果为2，整型
     print(1.1 + 2.2)  # 结果为3.300000000003，浮点数存储不精确，小数位数不确定
     print(1.1 + 2)  # 结果为3.1，浮点型
     # 减法
     print(2 - 1)  # 结果为1，整型
     print(2.2 - 3.1)  # 结果为-0.89999999999，浮点数存储不精确，小数位数不确定
     print(3.3 - 1)  # 结果为2.3，浮点型
     # 乘法
     print(2 * 5)  # 结果为10，整型
     print(2.2 * 5.5)  # 结果为12.100000000001，浮点数存储不精确，小数位数不确定
     print(5.5 * 3)  # 结果为16.5，浮点型
     
     # 解决方法，导入Decimal
     from decimal import Decimal
     
     print(Decimal('1.1') + Decimal('2.2'))  # 输出结果为3.3
     print(Decimal('2.2') - Decimal('3.1'))  # 输出结果为-0.9
     print(Decimal('2.2') * Decimal('5.5'))  # 输出结果为12.10
     

除法（ / ）

1. 就是普通除法，带小数运算

   # 除法 (得出的结果为浮点型)
   print(11 / 2)  # 结果为5.5
   print(-10 / 3)  # 结果为-3.3333333333335 (后面是5是因为浮点数的不精确性)
   # 解决方法，导入Decimal
   from decimal import Decimal
   
   print(Decimal('-10') / Decimal('3'))  # 输出结果为-3.3333333333333333
   c = 9 / 3
   print(c, type(c))  # 结果为3.0 (注意此处，得出的结果是浮点型)
   

求商（ // ）

1. 在其他语言中，求商的符号是 / ，求余的符号是 %

2. 向左取整（数轴的左边，高斯函数），即11 // 2= 5.5 输出的是 5

3. 如果被除数和除数一正一负，也同样适用，例如 (-10) // 3 = -4

   print(-11//5) #商为-3
   print(11//-5) #商为-3  一正一负，向左取整（数轴的左）高斯函数
   print(-10//3) #商为-4
   

求余（ % ）

1. 求余公式 ：余数 = 被除数 - 除数 * 商

   #求商
   print(10//4) #商为2
   print(-10//4) #商为-3  向左取整 -2.5向左取整为-3
   print(10//-4) #商为-3  向左取整  -2.5向左取整为-3
   
   #求余
   # Python 中的求余公式 余数=被除数-除数*商
   print(10%4)  #余数为2   10-4*2=8
   print(-10%4) #余数为2   (-10)-4*(-3) --> (-10)+12=2
   print(10%-4) #余数为-2  10-(-4)*(-3) -->  10-12=-2
   

幂运算（ ** ）

1. 指数运算

   # 幂运算(得出的结果为整型)
   print(2 ** 2)  # 结果为4
   print(2 ** 3)  # 结果为8
   d = 2 ** 6
   print(d, type(d))  # 结果为64(输出结果为整型)
   

比较运算符

应用举例：

a = b = c = 10  # 链式赋值，其id为同一个，即指向同一个对象
print(a is b)  # True,比较所指向对象的id
print(a == b)  # True，比较所指向对象的value

# 两个列表的值一样，但是其对象的id不一样
list1 = [1, 2, 3, 4]
list2 = [1, 2, 3, 4]
# list1 = list2 = [1, 2, 3, 4] 链式赋值，这种情况下两个列表所指向的对象的id一样
print(list1 is list2)  # False，比较两个列表的id
print(list1 is not list2)  # True
print(list1 == list2)  # True，比较两个列表的值

布尔运算符

应用举例：

c = 10
d = 20
print(c == 10 and d == 20)  # True
print(c != 10 or d == 20)  # True
print(not (c == 10))  # False

位运算符

1. 位运算符只能用来操作整型类型
2. 其先将整型转化为二进制再进行位运算（8位）

应用举例：

# 位运算符
a1 = 4  # 00000100
a2 = 8  # 00001000
b = 1
# 将整数化为二进制，将其向左\右移动b位，超出的位抹掉，缺的位补0
print(a1 << b)  # 8 将4转化为二进制（8位），再将其向左移一位
print(a2 >> b)  # 4 同理，这个是右移一位，这里的b是代表左移或者右移的位数
print(a1 & a2)  # 0 逐位相与
print(a1 | a2)  # 12 逐位相或

赋值运算符

应用举例：

# 赋值运算符
b1 = 2
b2 = 4
b1 += b2  # b1=b1+b2
print(b1)

运算符的优先级与结合性

Python中的组织结构

对象的布尔值

1. 用bool（）函数可以查看对象的布尔值

   # 布尔值为False的情况
   print(bool(''))  # 空字符串
   print(bool(""))  # 空字符串
   print(bool(0))  # 整型 0
   print(bool(0.0))  # 浮点型 0.0
   print(bool([]))  # 空列表
   print(bool(list()))  # 空列表
   print(bool(()))  # 空元组
   print(bool(tuple()))  # 空元组
   print(bool({}))  # 空字典
   print(bool(dict()))  # 空字典
   print(bool(set()))  # 空集合
   

分支结构

1. 单分支（if）

   写法举例（要注意缩进）：

   a = 10
   b = 20
   if a >= b:
       print(a)  
   

2. 双分支（if…else）

   写法举例（要注意缩进）：

   a = 10
   b = 20
   if a >= b:
       print(a)
   else:
       print(b)
   

3. 多分支（if…elif…else）

   写法举例（要注意缩进）：

   a = 10
   b = 20
   c = 30
   if a > b:
       print(a)
   elif a > c:
       print(b)
   else:
       print(c)
   

4. if语句的嵌套

   写法举例（要注意缩进）：

   a = 10
   b = 20
   c = 30
   if a < b:
       if a < c:
           print("最小值为%d" % a)
       else:
           print("最小值为%d" % c)
   else:
       pass
   

5. 条件表达式

   • 条件表达式是if…else的缩写

   写法举例：

   num1 = int(input('第一个整数:'))
   num2 = int(input('第二个整数:'))
   # if...else写法
   if num1 >= num2:
       print(str(num1) + '大于' + str(num2))
   else:
       print(str(num1) + '小于' + str(num2))
   # 条件表达式写法
   print((str(num1) + '大于' + str(num2)) if num1 >= num2 else (str(num1) + '小于' + str(num2)))
   

pass空语句

1. 空语句可以让程序正常运行，为未想好的代码留下位置

   应用举例：

   d = 100
   e = 200
   if d > e:
       pass
   else:
       pass
   

循环结构

1. range（）函数用于生成一个整数序列，其返回值是一个迭代器对象；不管range对象表示的整数队列有多长，所有range对象占用的内存空间的都是相同的，因为仅需要存储start（开始）、stop（结束）、step（步长），只有当用到range对象时，才会去计算序列中的相关元素；in与not in判断帧数序列中是否存在（不存在指定的整数）

   • 用法1（range（stop））

     用法举例：

     # range(stop)
     r = range(10)  # 到10结束，不包括10，默认从0开始，序列长度为：10-0=10
     print(r)  # range(0, 10)
     # 查看range对象中的整数序列
     print(list(r))  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
     
     

   • 用法2（range（start，stop））

     用法举例：

     # range(start,stop)
     g = range(1, 10)  # 从1开始，到10结束，不包括10，序列长度为：10-1=9
     print(g)  # range(1, 10)
     print(list(g))  # [1, 2, 3, 4, 5, 6, 7, 8, 9]
     

   • 用法3（range（start，stop，step））

     用法举例：

     # range(start,stop,step),step为步长，即相邻两个元素相差的差
     b = range(1, 10, 2)
     print(b)  # range(1, 10, 2)
     print(list(b))  # [1, 3, 5, 7, 9]
     print(10 in b)  # False,10不在b这个整数序列中
     print(3 in b)  # True，3在这个整数序列中
     
     # 倒序输出，步长为负数，倒序输出一定要写步长，要不然用list()输出为空
     E = range(100, 0, -1)  
     print(list(E))   # [100, 99, 98, 97, 96, 95....]
     

2. while循环

   写法举例：

   a = 1
   sum = 0
   while a < 5:
       sum += a
       a += 1
   print(sum)
   

3. for…in循环

   • for…in循环需要用到 range（）函数

     写法举例：

     D = range(0, 101, 2)  # 从0开始到100的偶数序列
     # print(list(D))  #[0, 2, 4, 6, 8, 10, 12.....]
     sum = 0
     for a in D:  # 从整数序列D中依次取数值出来赋给变量a
         sum += a  # 求和
     print(sum)  #2550
     

4. break语句

   • break语句用于跳出当前循环体；一般搭配 if 使用

     应用举例：

     a = 0
     while a < 3:
         str = input("请输入密码:")
         if str == "8888":
             print('密码正确')
             break  # 当密码正确的时候，直接跳出while循环
         else:
             print("密码错误")
             a += 1
     

     应用举例②：

     for a in range(1, 11):
         if a % 2 == 0:
             print(a)  # 只输出一次
             break
     

5. continue语句

   • continue语句用于结束当前循环，执行下一次循环；一般搭配 if 使用

     应用举例：

     for a in range(1, 11):
     if a % 2 != 0:
         continue  # 第一个数不是2的倍数，跳出a=1的循环，进行a=2的循环
     else:
         print(a)
     

6. else的三种应用

   • if…else

     应用举例：

     if a < 10:
         pass
     else:
         pass
     

   • for…in…else

     应用举例：

     # 九九乘法表
     for a in range(1, 10):
         for b in range(1, a + 1):
             print(a, '*', b, '=', a * b, end='\t')
         print()
     else:
         print("打印完毕")  # 执行完第一个for...in之后，就执行这个else
     

   • while…else

     应用举例：

     a = 0
     while a < 3:
         str = input("请输入密码:")
         if str == "8888":
             print('密码正确')
             break  # 当密码正确的时候，直接跳出while循环
         else:
             print("密码错误")
             a += 1
     else:
         print("三次密码都错误")  # 跳出while循环之后，执行这个else语句
     

Python中的列表

1. Python中的列表和数组很相似，但是列表存储的对象的类型可以不一样，而数组存储的对象类型一样

2. 列表的特点： 1）列表元素按顺序有序排序 2）索引映射唯一数据 3）列表可以存储重复数据 4）任意数据类型混存 5）根据需要动态分配和回收内存 6）列表是一个可变序列

3. 列表在内存中的存储方式

列表的创建

1. 使用中括号 [ ]

   # 用中括号创建列表
   List = ['hello', 1, 90, 'world']
   print(List)  # ['hello', 1, 90, 'wordl']
   print(List[2])  # 90   顺序索引: 'hello'的索引值0，1的索引值为1，以此类推
   print(List[-1])  # world  逆序索引：'world'的索引值为-1，90的索引值为-2，以此类推
   

2. 使用内置函数list（）

   # 用list()函数
   
   # 该方法和使用中括号的效果一样
   List = list(['hello', 1, 90, 'world'])
   print(List)  # ['hello', 1, 90, 'world']
   
   # 如果list()里面放的是字符串，那么list()函数会将字符串分割为一个字符分别存储到列表中
   List2 = list('hello world')
   print(List2)  # ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
   List3 = list('123456')
   print(List3)  # ['1', '2', '3', '4', '5', '6']
   
   # list()函数也可以搭配range()函数创建
   List4 = list(range(1, 10, 2))
   print(List4)  # [1, 3, 5, 7, 9]
   

3. 使用列表生成式

   # 列表生成式
   List = [i for i in range(1, 10, 1)]
   print(List)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]
   

列表的查询

1. 查询元素索引（使用 index（）方法）

   #List.index(对象值)
   List = list(['hello', 1, 90, 'world', 'hello'])
   print(List.index('hello'))  # 0  ;若列表中存在重复值，则只输出查找到的第一个索引值（顺序索引）
   print(List.index(1))  # 1
   

2. 获取单个元素（通过元素索引查询）

   • 元素索引分为顺序和逆序，顺序的索引从0开始，到N-1结束；逆序的索引从 -1 开始

     # 用中括号创建列表
     List = ['hello', 1, 90, 'world']
     print(List)  # ['hello', 1, 90, 'world']
     print(List[2])  # 90   顺序索引: ' hello '的索引值0，1的索引值为1，以此类推
     print(List[-1])  # world  逆序索引：' world '的索引值为-1，90的索引值为-2，以此类推
     

3. 获取多个元素

   • 在获取多个元素所使用到的切片操作时，其会在源列表的基础上产生一个新的列表

   # 切片语法结构
   # 列表名[start : stop :step]
   # 切片所使用的索引号为顺序索引号，从0开始，N+1结束
   List = [10, 20, 30, 40, 50, 60]
   
   # 步长为正数
   list1 = List[1:5:]  # 不标明step，步长默认为1，从索引号1开始，一直到索引号4结束，顺序切割
   print(list1)  # [20, 30, 40, 50]
   list2 = List[:5:2]  # 不标明start，则默认从索引号为0的开始,步长为2
   print(list2)  # [10, 30, 50]
   list3 = List[1::1]  # 不标名stop，则默认到最后一个索引结束
   print(list3)  # [20, 30, 40, 50, 60]
   
   # 步长为负数
   # 由于不标明的step默认值为1，所以在逆序切片的时候一定要标明step值
   list4 = List[5::-1]  # 不标明stop,从索引号为5的元素开始往左切片（逆序切片）,切到最后一个索引
   print(list4)  # [60, 50, 40, 30, 20, 10]
   list5 = List[:1:-2]  # 不标明start，默认从最后一个元素开始切片（步长为负数，逆序切片）
   print(list5)  # [60, 40]
   list6 = List[5:0:]  # 不标明step，默认步长为1，由于start为5大于stop0，故切出来的是空列表
   print(list6)  # []
   

4. 查询该元素是否在列表中（in / not in）

   # 使用 in/not in 判断
   List2 = [10, 20, 'hello', 'world']
   print(10 in List2)  # True
   print(100 not in List2)  # True
   print("Hello" in List2)  # False
   print("hello" in List2)  # True
   

列表的增删改

1. 增加元素

   • 使用 append（）方法

     # append()方法 在原列表的末尾添加一个元素
     list1 = [10, 20, 'Hello']
     list1.append(100)
     print(list1)  # [10, 20, 'Hello', 100]
     list1.append("world")
     print(list1)  # [10, 20, 'Hello', 100, 'world']
     lis = [10, 20]
     list1.append(lis)  # 将lis当作一个元素添加到列表尾部
     print(list1)  # [10, 20, 'Hello', 100, 'world', [10, 20]]
     

   • 使用 extend（）方法

     # extend()方法 在列表的末尾添加至少一个元素
     list2 = [10, 20, 'Hello']
     lis = ['world', 100]
     list2.extend(lis)
     print(list2)  # [10, 20, 'Hello', 'world', 100]
     

   • 使用 insert（）方法

     # insert()方法 在列表的任意位置添加一个元素
     list3 = [10, 20, 'Hello']
     list3.insert(1, 'world')  # 在索引为1的位置上添加'world'
     print(list3)  # [10, 'world', 20, 'Hello']
     

   • 切片

     # 切片在列表任意位置添加至少一个元素
     list4 = [10, 20, 'Hello', "world1", 99]
     lis = [1, "world2", 100]
     
     # 顺序切片（步长为1）添加多少个元素都行
     # list4[1:3]=lis #从索引号1开始，将索引号为1，2的元素删掉，并将lis中的元素放进去
     # 输出为 [10, 1, 'world2', 100, 'world1', 99]
     # list4[1::1]=lis  #从索引号1开始，将后面的所有元素切掉，并且将切掉的元素更改为lis列表中的元素
     # 输出为[10, 1, 'world2', 100]
     
     # 间隔切片（步长不为1）的时候；逆序切片（步长为负数）时，切掉多少个元素，只能放多少个元素进去（不能多，不能少）
     # 顺序切片只能顺序放入元素
     # 逆序切片只能逆序放入元素
     
     # list4[0:3:2]=lis
     # 报错，因为lis列表里有三个元素，而切片只切掉了索引号为0，2的元素，位置不够
     
     # list4[0::2]=lis  #从索引号0开始，因为只把索引号为0，2，4的元素切掉，所以只能插入三个元素
     # 输出为[1, 20, 'world2', 'world1', 100]
     
     # list4[4::-2]=lis  #从索引号4开始，逆序切片，把索引号为4，2，0的元素切掉
     # 输出为[100, 20, 'world2', 'world1', 1]，注意，逆序放入的！
     
     # list4[:0:-1]=lis  #从最后一个索引号开始，将索引号为5，4，3，2，1的元素切掉，但是由于是逆序，所以前面只能放四个元素
     # 报错，因为lis列表里面只有三个元素，而切片切掉了四个元素
     
     print(list4)
     

2. 删除元素

   • 使用 remove（）方法

     1. 重复元素只删除第一个
     2. 元素不存在则抛出ValueError

     # remove()方法
     # 一次只移除一个元素
     
     List1 = [10, 20, 30, 40, 50, 60, 30]
     List1.remove(30)
     print(List1)  # [10, 20, 40, 50, 60, 30]  只移除了20后面的30
     # 如果需要移除的元素不在列表里面，则会报错
     List1.remove(100)  # ValueError: list.remove(x): x not in list
     

   • 使用 pop（）方法

     1. 通过指定索引删除指定元素
     2. 若索引不存在，则抛出IndexError
     3. 若不指定索引，则默认删除最后一个元素

     # pop()方法
     # 删除指定元素
     
     List2 = [10, 20, 30, 40, 30]
     List2.pop(1)  # [10, 30, 40, 30]  20的索引为1，移除了20
     print(List2)
     # 指定索引不存在
     List2.pop(5)  # IndexError: pop index out of range
     List2.pop()  # [10, 30, 40]  移除了最后一个30
     print(List2)
     

   • 使用 clear（）方法

     1. 清楚列表所有元素

     # clear()方法
     # 清空列表所有元素
     List4 = [1, 2, 3]
     List4.clear()
     print(List4)  # []
     

   • 使用 del语句

     1. 将列表对象删除

     # def()语句
     # 删除列表对象
     List5 = [1, 2, 3, 4]
     del List5
     print(List5)  # NameError: name 'List5' is not defined
     

   • 切片

     1. 一次删除多个元素
     2. 只能删除连续索引号的元素，不能间隔删除元素
     3. 并不是真正的删除，只是把需要删除的元素用空列表替代
     4. step只能为1（默认值）

     # 切片
     # 删除至少一个元素
     List3 = [10, 20, 30, 40, 60, 20]
     # 连续删除元素
     List3[1:3:1] = []  # 将需要删除的元素用空列表代替
     print(List3)  # [10, 40, 60, 20]，将索引号为1和2的元素删除
     # 间隔删除元素（不可行）
     # 删除不了，会报错 ValueError: attempt to assign sequence of size 0 to extended slice of size 2
     # List3[1:5:2] = []  
     

3. 修改元素

   • 通过索引

     1. 一次修改一个元素

     # 通过索引
     List1 = [1, 2, 3, 50]
     List1[2] = 30  # 将索引号为2的元素替换为30
     print(List1)  # [1, 2, 30, 50]
     

   • 切片

     1. 一次修改多个元素

     # 切片
     List2 = [1, 30, 1, 50]
     # 顺序切除（步长为1）
     List2[1:3] = [100, 200, 300, 440]  # 将切除的位置放入新元素
     print(List2)  # [1, 100, 200, 300, 440, 50]
     

列表的排序

1. 使用sort（）方法

   • 在原列表上进行操作，不产生新的列表对象

     # sort()方法，默认升序排序
     list1 = [1, 3, 8, 10, 14]
     list1.sort()
     print(list1)  # [1, 3, 8, 10, 14]
     # 当reverse为True时，进行降序排序，若不指定reverse，则默认值为False
     list1.sort(reverse=True)  # 降序排序
     print(list1)  # [14, 10, 8, 3, 1]
     

2. 使用内置函数：sorted（）

   • 排序会产生新的列表对象

     # 调用内置函数sorted()，默认升序排序
     list2 = [10, 11, 1, 0, 2, 4, 20]
     new_list = sorted(list2)
     print(list2)  # [10, 11, 1, 0, 2, 4, 20]
     print(new_list)  # [0, 1, 2, 4, 10, 11, 20]
     # 当reverse为True时，进行降序排序，若不指定reverse，则默认值为False
     new_list = sorted(list2, reverse=True)
     print(new_list)  # [20, 11, 10, 4, 2, 1, 0]
     

Python中的字典

1. 字典中的所有元素都是一个key-value对
2. 字典与列表一样是一个可变序列（可进行增删改，但key为不可变对象）
3. 以键值对的方式存储数据，字典是一个无序序列（存入的key通过hash变换）
4. 字典是根据key查找value所在的位置
5. 字典中不出现重复的key，但value可以重复，若在一次定义中出现两个相同的key，则最后出现的一个key类似于更新了前面相同的key的值
6. 字典根据需要动态地伸缩，故其会浪费较大的内存，是一种空间换时间的数据结构
7. 字典是元素可变、value可重复、key不可重复、元素无序排列的数据结构（可以进行增、删、改）

字典的创建

1. 使用花括号 { }

   # 使用花括号
   # {key:value,key:value}
   score = {'张三': 100, '李四': 90, '王五': 80, '李六': '九十', '李六': '九十'}
   score2 = {}  # 空字典
   print(score, type(score))  # {'张三': 100, '李四': 90, '王五': 80, '李六': '九十'} <class 'dict'>
   

2. 使用内置函数dict()

   # 使用dict()函数
   # dict(key=value)
   people = dict(name='zhang', age=100, address='beijing')
   print(people, type(people))  # {'name': 'zhang', 'age': 100, 'address': 'beijing'} <class 'dict'>
   

3. 使用字典生成式

   • 内置函数zip ( )

     # 内置函数zip()
     Fruits = ['apple', 'orange', 'banana']
     Numbers = [100, 200, 101]
     new_dict = zip(Fruits, Numbers)
     print(list(new_dict))  # 要转化为列表才能输出，因为zip()返回的是“由这些元组组成的列表”
     

   • for…in…

     # 字典生成式
     Fruits = ['apple', 'orange', 'banana']
     Numbers = [100, 200, 101]
     A = {Fruits: Numbers for Fruits, Numbers in zip(Fruits, Numbers)}
     print(A)
     # 如果两个字典中的元素不相等,则以短的字典为主
     Tools = ['rule', 'desk', 'pen']
     Prices = [100, 10, 20, 30, 102]
     B = {Tools: Prices for Tools, Prices in zip(Tools, Prices)}
     print(B)  # {'rule': 100, 'desk': 10, 'pen': 20}
     

字典元素的获取

1. 使用[ ]

   # 使用[]
   score = {'张三': 100, '李四': 90, '王五': 80, '李六': '九十'}
   print(score['张三'])  # 通过key值查询相应的value值  100
   # print(score['zhang'])  # 查找的key值不存在，抛出 KeyError: 'zhang'
   

2. 使用get( )

   # 使用get(),get(key,self)
   print(score.get('李四'))  # 通过key值查询相应的value值 90
   print(score.get('zhang', 99))  # 查找相应的键值不存在，返回默认值99
   print(score.get('zhang'))  # 查找相应的键值不存在，返回None
   

字典元素的判断

1. key的判断

   # in / not in
   score = {'张三': 100, '李四': 90, '王五': 80, '李六': '九十'}
   print('zhang' in score)  # False
   print('张三' not in score)  # False
   

字典元素的增删改

1. 字典元素的增加

   # 字典元素的添加
   score = {'张三': 100, '李四': 90, '王五': 80, '李六': '九十'}
   score['成七'] = 88
   print(score)  # {'张三': 100, '李四': 90, '王五': 80, '李六': '九十', '成七': 88}
   

2. 字典元素的删除

   • del

     # 字典元素的删除
     score = {'张三': 100, '李四': 90, '王五': 80, '李六': '九十'}
     del score['张三']  # 通过指定key删除键值对
     print(score)  # {'李四': 90, '王五': 80, '李六': '九十'}
     

   • clear ( )

     # 清空字典元素
     score = {'张三': 100, '李四': 90, '王五': 80, '李六': '九十'}
     score.clear()
     print(score)  # {}
     

3. 字典元素的修改

   # 字典元素的修改
   score = {'张三': 100, '李四': 90, '王五': 80, '李六': '九十'}
   score['成七'] = 400
   print(score)  # {'张三': 100, '李四': 90, '王五': 80, '李六': '九十', '成七': 400}
   

字典视图的获取

1. key ( )

   # 获取字典中的所有key
   score = {'张三': 100, '李四': 90, '王五': 80, '李六': 100}
   print(score.keys())  # dict_keys(['张三', '李四', '王五', '李六'])
   print(type(score.keys()))  # <class 'dict_keys'>
   # 将key转化成列表
   print(list(score.keys()))  # ['张三', '李四', '王五', '李六']
   

2. value ( )

   # 获取字典中的所有value
   score = {'张三': 100, '李四': 90, '王五': 80, '李六': '九十'}
   print(score.values())  # dict_values([100, 90, 80, '九十'])
   print(type(score.values()))  # <class 'dict_values'>
   # 将value转化成列表
   print(list(score.values()))  # [100, 90, 80, '九十']
   

3. items ( )

   # 获取字典中的所有键值对
   score = {'张三': 100, '李四': 90, '王五': 80, '李六': 100}
   print(score.items())  # dict_items([('张三', 100), ('李四', 90), ('王五', 80), ('李六', 100)])
   print(type(score.items()))  # <class 'dict_items'>
   # 将键值对转化为列表
   print(list(score.items()))  # [('张三', 100), ('李四', 90), ('王五', 80), ('李六', 100)]
   

字典元素的遍历

# 字典元素的遍历
score = {'张三': 100, '李四': 90, '王五': 80, '李六': 100}
for i in score:
    print(i)  # 获取key
    print(score[i])  # 获取values
    print(score.get(i))  # 获取values

Python中的元组

1. 元组是Python内置的数据结构之一，是一个不可变序列

2. 元组是元素不可变、元素可重复、元素有序排列的数据结构（不可以进行增、删、改）

3. 将元组设计成不可变序列的好处：在多任务环境下，同时操作对象时不需要加锁

4. 元组中存储的是对象的应用，如果元组中对象本身不可变，则不能在引用其他对象；如果元组中的对象可变，则可变对象的引用不允许改变，但是数据可以改变

   # 元组是不可变序列
   A1 = (10, [10, 20], 30)
   # A1[1]=10 # TypeError: 'tuple' object does not support item assignment
   # 但是可以修改列表[10,20]
   A1[1].append(101)
   print(A1)  # (10, [10, 20, 101], 30)
   

元组的创建

1. 使用 ( )

   # 使用()
   A = ('Python', 10, 'Hello', 'Wordl')
   print(A, type(A))  # ('Python', 10, 'Hello', 'Wordl') <class 'tuple'>
   # ()也可以省略
   C = 'Hello', 'Worle', 100
   print(C, type(C))  # ('Hello', 'Worle', 100) <class 'tuple'>
   # 当元组中只有一个元素的时候，要在该元素后面添加逗号
   D = ('Hello',)
   F = 'HELLO',
   E = ('World')
   print(D, type(D))  # ('Hello',) <class 'tuple'>
   print(E, type(E))  # World <class 'str'>
   print(F, type(F))  # ('HELLO',) <class 'tuple'>
   # 空元组
   G = ()
   H = tuple()
   

2. 使用内置函数tuple ( )

   # 使用内置函数tuple()
   B = tuple(('Hello', 'World', 100))
   print(B, type(B))  # ('Hello', 'World', 100) <class 'tuple'>
   

元组的遍历

1. 使用for…in…

   # 元组的遍历
   B1 = ('Hello', 'World', 10)
   for i in B1:
       print(i)  # Hello World 10
   

2. 使用索引

   # 元组的遍历
   C1 = (10, 20, 30)
   print(C1[1])  # 20
   

Python中的集合

1. 集合是Python提供的内置数据结构
2. 集合是元素可变、元素不可重复、元素无序排列的数据结构（可以进行增、删、改）
3. 集合是没有value的字典
4. 集合定义和字典类似，也使用 { }

集合的创建

1. 使用 { }

   # 使用 { }
   A = {1, 2, 'Hello'}
   # 体现集合是无序序列
   print(A, type(A))  # {1, 2, 'Hello'} <class 'set'>
   

2. 使用内置函数set ( )

   # 内置函数set()
   B = set({1, 'Hello'})
   print(B, type(B))  # {1, 'Hello'} <class 'set'>
   C = set(range(5))
   print(C, type(C))  # {0, 1, 2, 3, 4} <class 'set'>
   D = set([1, 2, 3, 4])
   print(D, type(D))  # {1, 2, 3, 4} <class 'set'>
   E = set(('hello', 20))
   print(E, type(E))  # {'hello', 20} <class 'set'>
   F = set('Python')
   print(F, type(F))  # {'y', 'o', 'P', 'n', 'h', 't'} <class 'set'>
   # 空集合
   G1 = {}  # 这个是定义空字典
   G = set()
   print(G, type(G))  # set() <class 'set'>
   

3. 使用集合生成式

   # 集合生成式
   A = {i * i for i in range(1, 10)}
   print(A)  # 无序排序 {64, 1, 4, 36, 9, 16, 49, 81, 25}
   

集合的相关操作

1. 集合元素的判断

   # in或not in
   A1 = {11, 22, 'Hello'}
   print(11 in A1)  # True
   print('HELLO' in A1)  # False
   

2. 集合元素的增加

   • add ( )

     # add() 一次添加一个元素
     B1 = {1, 2, 3}
     B1.add(80)
     print(B1)  # {80, 1, 2, 3}
     

   • update ( )

     # update() 至少添加一个元素
     C1 = {1, 2, 3}
     C1.update({22, 33})
     C1.update([44, 55])
     C1.update((66, 77))
     print(C1)  # {1, 2, 3, 66, 77, 22, 33, 44, 55}
     

3. 集合元素的删除

   • remove ( )

     # remove() 一次删除一个指定元素
     D1 = {1, 2, 3}
     D1.remove(1)  # {2, 3}
     print(D1)
     # D1.remove(100) #KeyError: 100
     

   • discard ( )

     # discard() 一次删除一个指定元素
     E1 = {11, 22, 10}
     E1.discard(11)
     print(E1)  # {10, 22}
     E1.discard(100)  # 移除不存在的元素不会报错
     

   • pop ( )

     # pop() 一次只删除一个元素,该元素索引号为0
     F1 = {11, 12, 13}
     # F1.pop(11) #报错,pop()不可指定参数
     print(F1)  # {11, 12, 13}
     F1.pop()
     print(F1)  # {12, 13}
     F1.pop()
     print(F1)  # {13}
     

   • clear ( )

     # clear() 清空集合
     G1 = {11, 22}
     print(G1)  # {11, 22}
     G1.clear()
     print(G1)  # set(),空集合
     

集合间的关系

1. 是否相等

   # 两个集合是否相等
   A = {40, 10, 20, 30}
   B = {30, 20, 10, 40}
   print(A == B)  # True
   print(A != B)  # False
   

2. A是否是B的子集

   # A是否为B的子集
   C = {11, 22, 33}
   D = {33}
   print(D.issubset(C))  # True D是C的子集
   

3. A是否是B的超集

   # A是否为B的超集
   # 子集与超集的概念刚好相反
   C = {11, 22, 33}
   D = {33}
   print(C.issuperset(D))  # True C是D的超集
   

4. 是否没有交集

   # A与B是否没有交集
   C = {11, 22, 33}
   D = {33}
   print(C.isdisjoint(D))  # False C与D有交集
   

集合的数据操作

1. 交集

   # 交集
   C = {11, 22, 33}
   D = {33}
   print(C.intersection(D))  # {33}
   print(C & D)  # {33}
   # 集合并没有发生改变
   print(C)  # {33, 11, 22}
   print(D)  # {33}
   

2. 并集

   # 并集
   C = {11, 22, 33}
   D = {33, 44}
   print(C.union(D))  # {33, 22, 11, 44}
   print(C | D)  # {33, 22, 11, 44}
   

3. 差集

   # 差集
   C = {11, 22, 33}
   D = {33, 44}
   print(C.difference(D))  # 属于C但不属于D的元素 {11, 22}
   print(C - D)  # {11, 22}
   

4. 对称差集

   # 对称差集
   C = {11, 22, 33}
   D = {33, 44}
   print(C.symmetric_difference(D))  # 并集-交集 {11, 44, 22}
   print(C ^ D)  # {11, 44, 22}
   

print(F1) # {13}
```

• clear ( )

  # clear() 清空集合
  G1 = {11, 22}
  print(G1)  # {11, 22}
  G1.clear()
  print(G1)  # set(),空集合
  

集合间的关系

1. 是否相等

   # 两个集合是否相等
   A = {40, 10, 20, 30}
   B = {30, 20, 10, 40}
   print(A == B)  # True
   print(A != B)  # False
   

2. A是否是B的子集

   # A是否为B的子集
   C = {11, 22, 33}
   D = {33}
   print(D.issubset(C))  # True D是C的子集
   

3. A是否是B的超集

   # A是否为B的超集
   # 子集与超集的概念刚好相反
   C = {11, 22, 33}
   D = {33}
   print(C.issuperset(D))  # True C是D的超集
   

4. 是否没有交集

   # A与B是否没有交集
   C = {11, 22, 33}
   D = {33}
   print(C.isdisjoint(D))  # False C与D有交集
   

集合的数据操作

1. 交集

   # 交集
   C = {11, 22, 33}
   D = {33}
   print(C.intersection(D))  # {33}
   print(C & D)  # {33}
   # 集合并没有发生改变
   print(C)  # {33, 11, 22}
   print(D)  # {33}
   

2. 并集

   # 并集
   C = {11, 22, 33}
   D = {33, 44}
   print(C.union(D))  # {33, 22, 11, 44}
   print(C | D)  # {33, 22, 11, 44}
   

3. 差集

   # 差集
   C = {11, 22, 33}
   D = {33, 44}
   print(C.difference(D))  # 属于C但不属于D的元素 {11, 22}
   print(C - D)  # {11, 22}
   

4. 对称差集

   # 对称差集
   C = {11, 22, 33}
   D = {33, 44}
   print(C.symmetric_difference(D))  # 并集-交集 {11, 44, 22}
   print(C ^ D)  # {11, 44, 22}