Python笔记

一、软件概述

1.软件的定义

是指一组有序的计算机数据和指令的集合，它们被设计、开发、测试和打包，以实现特定功能、解决问题或满足用户需求。这些数据和指令以电子形式存储在计算机硬件上，并通过计算机系统进行处理和执行。

2.软件的分类

系统软件：

为计算机系统提供基本服务和功能，如操作系统（OS）、驱动程序、编译器、数据库管理系统等。它们管理硬件资源，提供用户与计算机硬件之间的接口，并支持其他软件的运行。

Windows ，Android，IOS ，Harmony 主要负责管理和调控计算机硬件，给用户提供最基本的计算机功能（磁盘管理，上网管理，内存管理， 用户管理......）

应用软件：

面向特定用户需求或特定任务而开发，如文字处理软件（如Microsoft Word）、图像编辑软件（如Adobe Photoshop）、财务管理软件、社交媒体应用程序、游戏等。应用软件在系统软件的支持下运行，直接服务于最终用户。

微信 优酷 支付宝 网易云 提供专业领域服务的软件，是基于操作系统软件运行的

二、编程语言

1.机器语言：直接使用二进制码编写，依赖于特定硬件。

2.汇编语言：使用助记符代替二进制码，与特定硬件体系结构紧密相关。

3.高级语言：如FORTRAN、COBOL、BASIC等，抽象程度更高，更接近人类自然语言，不需要关心底层硬件细节。

进阶知识：

静态编译型：C C++ Java等

动态解释型：Python JavaScript （脚本语言） 

编译与解释的区别：

• 转化过程：编译是将源代码一次性转换成可独立执行的目标代码；解释则是边读取源代码边解释执行。
• 执行速度：编译型语言通常执行速度快，因为执行的是预编译的目标代码；解释型语言执行速度相对较慢，因为每次执行都需要解释源代码。
• 错误检测：编译型语言在编译阶段就能发现大部分语法和类型错误；解释型语言在执行过程中实时检测并报告错误。
• 源代码依赖：编译后的程序可以脱离源代码独立运行；解释型语言运行时依赖源代码的存在。

静态与动态的区别：

静态对于变量有明确的类型定义的

动态对变量没有明确类型定义的

在C C++ Java中，基本数据类型变量（将常量数据存储在变量空间当中）

int a = 3; int b = 4;

在C C++中，指针变量（存储的是变量的物理内存地址）

在Java中，引用数据类型变量（将对象在堆内存中的地址给变量）

Object obj = new Object(); Object obj2 = obj;

动态语言（所有的数据都是对象！所有的变量都是引用数据类型变量）

var = 1 var b = 1.1 b = new object();

三、脚本模式与交互模式

1、交互模式

 交互模式，也称为REPL（Read-Eval-Print Loop，即读取-求值-打印循环），提供了一个实时的交互式环境，用户可以直接在Python提示符（如>>>）后输入单行或多行代码，并立即得到执行结果。

打开CMD窗口，输入python指令，进入到了python交互模式

特点：

• 即时反馈：每输入一条语句并回车后，Python解释器立刻执行该语句并显示结果，非常适合学习、试验语法、验证想法或快速计算。
• 探索性编程：便于对数据结构、库函数等进行实时探索和交互，无需创建、保存和运行完整的脚本文件。
• 调试便捷：能够立即观察到代码执行的效果，方便进行调试和问题定位，特别是在处理小规模问题或进行算法原型设计时。
• 环境保持：在同一个交互式会话中，定义的变量、导入的模块等状态会被保留，直到会话结束或显式清除。

2、脚本模式

脚本模式是指将Python代码写入一个文本文件（通常以.py为扩展名），作为独立的程序或脚本进行保存。这些脚本文件包含了完整的程序逻辑，可以包含变量声明、函数定义、类定义、控制结构（如循环、条件判断）以及程序入口点（如主函数或直接可执行的代码段）。

特点：

• 持久性：代码被保存在文件中，可以反复执行而不必重新键入。
• 结构化：适合编写结构化、模块化的程序，可以包含多个函数、类等组织良好的代码结构。
• 批处理：适用于自动化任务、数据处理、科学计算等需要一次性处理大量数据或执行复杂逻辑的情况。
• 调试：虽然脚本模式下可以使用各种调试工具（如pdb），但调试过程通常不如交互模式直观，可能需要添加额外的打印语句或使用专门的调试器。

四、基本数据类型

1. 数字

   • 整数（int）: 表示没有小数部分的正负整数，如 123, -456。在Python 3中，整数类型没有预设的最大值限制，可以表示非常大或非常小的整数值。注意：没有byte short long 之分 一律默认int
   • 浮点数（float）: 用于存储带有小数点的实数，如 3.14, -0.0001。浮点数提供了有限的精度，受到计算机内部表示的限制。注意：没有float与double之分 默认float
   • 复数（complex）: 由实部和虚部组成，
   • 布尔型（bool）: 表示逻辑值，仅有两个取值 True 和 False。在Python中，布尔型是整数的子类型，True 等价于 1，False 等价于 0，因此它们可以参与数值运算。 

2. 字符串（String）

   字符串是用来存储文本数据的序列类型。它们由零个或多个字符（包括字母、数字、标点符号等）组成，用单引号 '...' 或双引号 "..." 包围。

3. 标识符

                  

1. 字符构成： 标识符由以下字符组成：

   • 字母（包括大小写字母，ASCII或Unicode字符集）
   • 数字（0-9）
   • 下划线 _

2. 首字符限制： 标识符必须以字母（a-z, A-Z）或下划线 _ 开头，不能以数字开头。

3. 保留字： 标识符不能与Python的保留字（关键字）相同。保留字是一组具有特殊意义、预留给Python语言内部使用的单词，如if, for, class, while, def等。使用保留字作为标识符会导致语法错误。

4. 大小写敏感： Python是大小写敏感的语言，这意味着myVariable和myvariable被视为两个不同的标识符。

5. 特殊字符禁用

6. 规范： 小驼峰：变量 函数 多个单词出现时 第一个单词首字母小写 之后单词首字母都大写 myName 大驼峰：类 所有单词首字母大写 MyName 下划线分割：单词之间用下划线分割 不大写 my_name 起的任何名字必须有含义，就算英文单词记得不多，也可以允许用拼音

注释

 单行注释          # 后面就是注释的内容 直到换行为止

  多行注释          """ 中间多行注释 """      单引号双引号都可以

 变量

在Python当中 变量其实就是一个万能箱子 他可以存储任何数据 本质：变量它只存储数据在内存中的地址（引用类型变量）

数据转换

#任何类型都可以转换成字符串，字符串内只有全都是数字才能转换成数字
#整数转字符串
int_str=str(100)
#小数转字符串
float_str=str(789.456)
#小数转整数  小数转换成整数会丢失精度
float_int1=int(123.456)
float_int2=int(34.5678)
#整数转小数
int_float=float(99)
#字符串转小数
str_float=float("66")
#字符串转整数
str_int=int("33")
#查看类型
print(type(int_str),int_str)
print(type(float_str),float_str)
print(type(float_int1),float_int1)
print(type(float_int2),float_int2)
print(type(int_float),int_float)
print(type(str_float),str_float)
print(type(str_int),str_int)

int() 将其他有效的数据转为整数；float()：将其他的数据转为小数；str()：将其他数据转字符串；

bool()：将其他数据转布尔类型

进制转换

> bin(123) # 转二进制字符串
'0b1111011'
>>> oct(123) # 转八进制字符串
'0o173'
>>> hex(123) # 转十六进制字符串
'0x7b'

字符与ASCII码转换

a~z A~Z 0~9 他们在ASCII中的编号都是连续的

ord()：获取字符对应的ASCII码编号

chr()：根据给定的ASCII码编号获取对应的字符

>>> ord('a')
97
>>> ord('A')
65
>>> ord('0')
48
>>> chr(98)
'b'
>>> chr(57)
'9'

常见的数学计算

 abs(3.14)                    # 取绝对值

3.14 

pow(2, 4)                       # 求a 的 b 次幂

16 

max(1, 2, 3, 4)                 # 求最值问题

4 

 round(3.14)                         #四舍五入

3

输入与输出

input()

#num = int(input("请输入一个数字:"))
num = eval(input("请输入一个数字:"))
# input()默认输入的是一个字符串(整行)
print(num + 1)
"""
TypeError: can only concatenate str (not "int") to str
反向证明输入的是字符串
ValueError: invalid literal for int() with base 10: '123 456'
"""
# 处理一行内多个数据的输入
# eval处理的数据必须要有逗号分隔
# eval自动处理字符串解析
# eval既可以处理单值 也可以处理多值
"""
请输入两个数字:123,456
579
"""
num1, num2 = eval(input("请输入两个数字:"))
print(num1 + num2)

print()

print("Hello World")
print(1 + 2 + 3)
print(1, 2, 3, "Hello World!") # 多数据输出 用空格分隔
print(1, 2, 3, sep = "#") # sep默认空格
print(1, 2, 3, end = "!!!") # end输出的解围 默认"\n"
# print(*args, sep=' ', end='\n', file=None, flush=False)
print(1, 2, 3, end = "!!!")
print("Hello World", end = "!!!")
print("Hello World", end = "!!!")
print() # 单独一个print换行的意思 其实打印的是空串
# 格式化输出
name = "旺财"
age = 18
height = 1.23
print("它叫", name, "，今年", age, "岁", sep = "")
# %s 对应字符串 %d 对应整数 %f 对应小数
print("它叫%s，今年%d岁，身高%.2f米" % (name, age, height))

    

运算符

        1. 算术运算符

                加法 (+): 合并两个数值或连接两个字符串。

                减法 (-): 从第一个数中减去第二个数。

                乘法 (*): 将两个数相乘或字符串重复。

                除法 (/): 除以第二个数并返回一个浮点数结果。

                整数除法 (//): 除以第二个数并返回一个整数结果（向下取整）。

                取余 (%): 返回除法的余数。

                幂运算 (**): 计算第一个数的第二个数次幂。

        2. 比较运算符

                等于 (==): 检查两个值是否相等。

                不等于 (!=): 检查两个值是否不相等。

                大于 (>): 检查左边的值是否大于右边的值。

                小于 (<): 检查左边的值是否小于右边的值。

        3. 逻辑运算符

                与 (and): 两边的条件都为 True 时，整个表达式才为 True。

                或 (or): 只要两边的任一条件为 True，整个表达式就为 True。

                非 (not): 对布尔值进行否定。

        4. 位运算符

                位与 (&): 对应位均为1时，结果位为1，否则为0。

                按位或 (|): 只要对应位中有1，结果位就为1，否则为0。

                按位异或 (^): 对应位相同为0，不同为1。

                按位取反 (~): 对整数的每一位进行取反（0变1，1变0）。

                左移 (<<): 将整数的所有位向左移动指定次数，右边补0。

                右移 (>>): 将整数的所有位向右移动指定次数，对于正数，左边补0；对于负数，取决于实现（通常补符号位）。

   5、赋值运算符

                加法赋值 (+=): 相当于 a = a + b。

                减法赋值 (-=): 相当于 a = a - b。

                乘法赋值 (*=): 相当于 a = a * b。

                除法赋值 (/=): 相当于 a = a / b。

                整数除法赋值 (//=): 相当于 a = a // b。

                取余赋值 (%=): 相当于 a = a % b。

                幂赋值 (**=): 相当于 a = a ** b。

                按位与赋值 (&=): 相当于 a = a & b。

                按位或赋值 (|=): 相当于 a = a | b。

  条件判断语句

  if 语句用于检查一个条件，如果条件为真（True），则执行相应的代码块；如果条件为假（False），则跳过该代码块。

score = 85

if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")

  

简化版的条件判断，只包含一个条件和一个对应的代码块，以及一个可选的 else 子句，用于在条件为假时执行。

 循环语句 

for 循环用于遍历序列（如列表、元组、字符串）或其他可迭代对象，依次执行循环体内的代码。

for i in range(1, 6):
    print(i * "*")

# 输出：
# 1*
# 2**
# 3***
# 4****
# 5*****

while 循环在给定条件为真时持续执行循环体内的代码，直到条件变为假为止。

number = 1

while number <= 5:
    print(number)
    number += 1

# 输出：
# 1
# 2
# 3
# 4
# 5

数组列表

序列：存储一堆数据的集合/容器

列表、字符串、元组、集合、字典

序列通用操作

索引/角标 

• 正数索引从 0 开始，表示从列表左侧开始计数。
• 负数索引从 -1 开始，表示从列表右侧开始计数，-1 指向最后一个元素。

>>> arr = [1,2,3,4,5,6,7,8,9]     创建一个列表
>>> arr[0]              列表的第一个值  索引为[0]
1
>>> arr[8]              列表的第九个值  索引为[8]
9
>>> arr[-1]             列表倒数第一个   索引为负数时，为倒数

9
>>> arr[-3]             列表倒数第三个
7
>>> arr[-10]            超出列表范围 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

切片

列表切片的基本语法list_name[start:end:step]，其中：

• list_name：要进行切片操作的列表。
• start：切片开始的位置（包含）。默认值为 0，即列表的起始位置。
• end：切片结束的位置（不包含）。默认值为列表的长度，即取到列表的最后一个元素前。
• step：切片的步长，即在列表中移动的间距。默认值为 1，表示连续取值。负值表示反向取值。

lst = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 取前三个元素
slice_1 = lst[:3]  # 结果: [0, 1, 2]

# 取从第三个元素到第七个元素
slice_2 = lst[2:7]  # 结果: [2, 3, 4, 5, 6]

# 取从第三个元素到倒数第二个元素，步长为 2
slice_3 = lst[2:-1:2]  # 结果: [2, 4, 6]

# 反向取值，步长为 -1
slice_4 = lst[::-1]  # 结果: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# 取倒数第三个到倒数第一个元素，步长为 -2
slice_5 = lst[-3::-2]  # 结果: [7, 5, 3]

• 切片操作不会改变原列表，而是返回一个新的列表。
• 切片表达式可以跨越列表长度，Python 会自动处理边界情况，如 lst[10:] 或 lst[:-10]，不会引发错误。
• 省略切片参数意味着使用默认值，如 lst[start:] 表示从 start 位置取到列表末尾，lst[:end] 表示从列表开始取到 end 位置前，lst[::step] 表示以 step 为步长取完整列表。

列表连接

1.使用加法操作符 +：

两个或多个列表可以通过加法操作符 + 进行连接，生成一个新的列表，原列表不变。

list1 = [1, 2, 3]

list2 = [4, 5, 6]

combined_list = list1 + list2            # 结果: [1, 2, 3, 4, 5, 6]

2.使用 extend() 方法：

如果希望将一个列表的内容添加到另一个列表的末尾，可以使用 extend() 方法。这种方法直接修改原列表，不会创建新列表。

list1.extend(list2)                   # list1 现在为 [1, 2, 3, 4, 5, 6]

列表重复

使用乘法操作符 *： 列表可以与一个整数相乘，生成一个新的列表，其中原列表的内容重复指定次数。原列表保持不变。

original_list = [1, 2, 3]

repeated_list = original_list * 3                  # 结果: [1, 2, 3, 1, 2, 3, 1, 2, 3]

长度与最值

 len() 

可以获取列表的长度，即列表中元素的个数。

my_list = [3, 7, 2, 5, 9, 1]

list_length = len(my_list)

print(list_length)           # 输出：6

max() 和 min() 

分别获取列表中的最大值和最小值。

numbers = [3, 7, 2, 5, 9, 1]

max_value = max(numbers)

min_value = min(numbers)

print(max_value)              # 输出：9

print(min_value)               # 输出：1

创建问题

1.直接初始化

使用方括号 [] 包围一系列逗号分隔的元素即可创建一个列表。元素可以是任何数据类型，包括其他列表（嵌套列表）。

empty_list = []                 # 创建一个空列表

numbers = [1, 2, 3, 4, 5]                      # 创建一个包含整数的列表

mixed_list = [True, "hello", 3.14, [1, 2, 3]]                   # 创建一个包含多种数据类型的列表

存储多个数据 数据不一定都是同一个类型 但是为了方便操作 建议存一样的类型

可以通过索引/角标来访问

用一对中括号[]

2.使用 list() 函数： 

list() 函数可以将其他可迭代对象（如字符串、元组、集合、其他列表等）转换为列表。此外，它可以接受一个空参数或没有参数来创建一个空列表。

string_to_list = list("hello")                    # ["h", "e", "l", "l", "o"]

tuple_to_list = list((1, 2, 3))                        # [1, 2, 3]

range_to_list = list(range(1, 6))           # [1, 2, 3, 4, 5]

empty_list = list()                      # []

3.使用列表推导式（List Comprehensions）：

列表推导式是一种简洁的创建列表的方式，它允许在一行代码中根据现有数据结构或条件生成新的列表。

squares = [x**2 for x in range(1, 6)]                 # [1, 4, 9, 16, 25]

even_numbers = [num for num in range(10) if num % 2 == 0]                # [0, 2, 4, 6, 8]

• 左侧：新列表元素的生成表达式，通常是对循环变量进行某种操作。
• 中间：for 循环，定义如何遍历数据源。
• 可选：一个 if 子句，用于过滤满足特定条件的元素。

# 创建1~100当中 偶数

arr = [x for x in range(1, 101) if x % 2 == 0] 

遍历

for 循环遍历：

最常用且直观的方法是使用 for 循环配合 in 关键字。这种方式直接访问列表中的每个元素，不需要关心索引。

# 通过角标遍历

for i in range(len(arr)):

print(arr[i])

# 通过foreach遍历

for num in arr:

print(num)

使用 range() 和 len() 配合 for 循环：

当需要索引来访问元素时，可以结合 range() 函数（生成指定范围的整数序列）和 len() 函数（获取列表长度）来遍历。

fruits = ["apple", "banana", "cherry"]

for index in range(len(fruits)):

print(fruits[index]

最值问题

arr = [1,2,3,4,5,6,7,8,9]

# 最大、小值

maxNum = arr[0]

minNum = arr[0]

for i in range(1, len(arr)):

        if arr[i] > maxNum:

                maxNum = arr[i]

        if arr[i] < minNum:

                minNum = arr[i]

print(maxNum) print(minNum)

存在性问题

1.使用 in 关键字：

Python 提供了简单直观的 in 关键字用于检查列表中是否存在某个元素。返回值为布尔类型 (True 或 False)。

fruits = ["apple", "banana", "cherry"]

if "banana" in fruits:

        print("Banana is in the list.")

else:

        print("Banana is not in the list.")
2.使用 not in 关键字：

相反地，可以用 not in 来判断元素是否不在列表中。

if "orange" not in fruits:

        print("Orange is not in the list.")

3.使用 any() 函数：

当需要检查列表中是否存在至少一个满足特定条件的元素时，可以结合 any() 函数和 lambda 表达式或定义好的函数。

# 检查是否有长度大于5的水果名

if any(len(fruit) > 5 for fruit in fruits):

        print("There is a fruit with a name longer than 5 characters.")

翻转问题

1.使用 reverse() 方法：

Python 列表提供了一个内置的 reverse() 方法，可以直接对原列表进行翻转操作。该方法会改变原列表的内容，不返回新列表。

fruits = ["apple", "banana", "cherry"]

fruits.reverse()

print(fruits)                   # 输出：['cherry', 'banana', 'apple']

2.使用切片操作：

如果不想直接修改原列表，可以使用切片语法创建原列表的翻转副本。切片操作 [start:end:step] 中，省略 start 和 end 参数，只指定 step 为 -1，即可实现翻转。

fruits = ["apple", "banana", "cherry"]

reversed_fruits = fruits[::-1]  

print(reversed_fruits)         # 输出：['cherry', 'banana', 'apple']

print(fruits)               # 输出：['apple', 'banana', 'cherry'] 原列表未改变

查找算法

二分查找

1. 有序性：要求列表必须是有序的（通常为升序）。
2. 分割：每次将列表分为两半，比较目标值与中间元素。
3. 决策：如果目标值等于中间元素，查找结束；如果目标值小于中间元素，继续在左半部分查找；如果目标值大于中间元素，继续在右半部分查找。
4. 递归或循环：通过递归或循环不断重复以上步骤，直到找到目标值或确定目标值不存在于列表中。、

arr = [1,2,3,4,5,6,7,8,9]

minIndex = 0            #初始化搜索范围的左边界（最小索引）为0 

maxIndex = len(arr) - 1 

#初始化搜索范围的右边界（最大索引）为列表长度减1，即最后一个元素的索引。

midIndex = (minIndex + maxIndex) // 2   

#计算搜索范围的中间索引，使用整数除法（//）确保结果为整数。

key = 8            #要查找的目标值

while arr[midIndex] != key:            #只要中间索引处的元素不等于目标值 key，就继续循环。

        if arr[midIndex] < key:             #检查中间索引处的元素是否小于目标值

                minIndex = midIndex + 1       

#将左边界更新为中间索引加1，将搜索范围缩小到中间索引右侧

        else:

                maxIndex = midIndex - 1     

#将右边界更新为中间索引减1，将搜索范围缩小到中间索引左侧。

if minIndex > maxIndex:             #检查是否左边界超过了右边界，即搜索范围为空

                midIndex = -1                   #将中间索引设置为-1，表示未找到目标值

                break

        midIndex = (minIndex + maxIndex) // 2               

#在循环继续的情况下，重新计算搜索范围的中间索引

print(midIndex)                     

#打印中间索引。如果找到了目标值，此时的中间索引就是目标值在列表中的索引；如果未找到，中间索引为-1。