初学python

一、python是解释型语言

1. 执行方式：写的程序不需要编译成机器语言，它相当于有一个解释器，一边解释一边运行，每次运行都要将源代码解释成二进制码（CPU直接识别码）执行，所以效率相对编译型语言要低。
2. 跨平台性：一边解释一边运行，所以只要安装了其解释器，就可以跨平台运行。但是编译型语言不能跨平台运行，例如C++等语言写的程序在windows下用VS编译后生成exe文件，只能在windows中运行，不能在linux下运行，要想在linux下运行，必须在linux下重新编译。
3. 调试过程：在程序开发时，python没有编译这个环节。解释器在解释源代码时，会先检查语法，如果语法有问题，就报错。Python在程序运行前没有检查语法是否有错误，只有在运行时才检查。所以在开发过程中方便修改程序。但是编译型语言在程序开发时需要编译，如果程序中有语法错误，编译不通过，不能生成可执行文件。也就无法执行程序。因此编译型语言在程序开发阶段就必须彻底没有语法错误。

二、静态与动态的区别

静态：在编译时变量的数据类型就已经确定。多数静态类型语言要求在使用变量之前必须声明数据类型。

动态：变量的数据类型在运行时确定。在变量使用之前，不需要进行类型声明，变量的类型通常是由赋值的那个值的类型决定。

三、脚本与交互

交互模式中代码不能持久保存，代码随着窗口关闭而消失，一般在做简单的代码演示、测试会使用到交互模式。为了永久保存代码，需要脚本模式。

四、基本数据

• 常量

整数常量，注意 没有byte short long 之分 默认int

        

123 % 7 = 4
17 % 7 = 3
2 % 7 = 2
234 七进制
4*7^0+3*7^1+2*7^2=4+21+98=123
进制转换

小数常量，注意 没有float与double之分 默认float

>>> print(1.34)
1.34
>>> print(0.12e10) #0.12*10^10
1200000000.0

字符串常量Python没有字符的数据，一律当成字符串处理，双引号和单引号都可以表示字符串

>>> print("1+2+3")
1+2+3
>>> print('1+2+3')
1+2+3

>>> print("张老师说:"好好学习"")
File "<stdin>", line 1
print("张老师说:"好好学习"")
^^^^^^^^^^^
SyntaxError: invalid syntax. Perhaps you forgot a comma?
>>> print("张老师说:'好好学习'")
张老师说:'好好学习'

布尔值常量

只有两个值 True ， False ， T 和 F 是大写的

>>> print(True + 1)
2
>>> print(False + 1)
1

复数常量

>>> 1+2j
(1+2j)
>>> complex(1,2)
(1+2j)
>>> (1+2j)*(1-2j)
(5+0j)

标识符

就是我们程序员自定义的一些名称（变量 函数 类）

规则：

由字母、数字、下划线、美元符组成

数字不能开头

是一个连续的词，中间不能有空格分开

规范：

小驼峰：变量 函数 多个单词出现时 第一个单词首字母小写 之后单词首字母都大写 myName

大驼峰：类 所有单词首字母大写 MyName

下划线分割：单词之间用下划线分割 不大写 my_name

起的任何名字必须有含义，就算英文单词记得不多，也可以允许用拼音

关键字

被Python赋予了特殊的含义，不能随便使用。例如：'False', 'None', 'True', 'and', 'as', 'assert'等等。

>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break',
'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for',
'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or',
'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

内置函数名/类名

内置函数就是Python自带的一些具有特殊功能的函数，例如：print,max,min,input等等。

需要注意的是我们在使用内置函数的时候，一定要注意名称不能够被更改。

>>> print(123)
123
>>> print = 3
>>> print + 4
7
>>> print(7)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable

>>> print(3)
3
>>> show = print # 把print指向的那个函数给了show
>>> print = 3 # 把3对象的地址给了print
>>> print + 4
7
>>> show(7)
7

>>> max(432,5443,1,2,5,6,78,4,5,435)
5443
>>> max = 10
>>> max(1,2,3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable

所以，我们在使用内置函数的时候，一定要注意名称不能够被更改

注释

单行注释

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

多行注释

"""

中间多行注释

"""

变量

在Python当中，变量其实就是一个万能箱子，它可以存储任何数据。

本质：变量它只存储数据在内存中的地址（引用类型变量）

#数据类型 变量名 = 数据 # C Java
变量 = 数据
单独定义一个变量时
>>> a = 1
>>> b = 2
同时定义多个变量，给定多个数据
>>> a, b, c = 1, 2, 3
>>> a
1
>>> b
2
>>> c
3
多个变量的值是一样的
>>> a = b = c = 1
>>> a
1
>>> b
1
>>> c
1

五、数据转换

数据类型转换

int() 将其他有效的数据转为整数

• 取整
• 从字符串中解析整数

>>> int(3.14) # 将小数进行取整操作
3
>>> int("123") # 将数字字符串进行解析（默认十进制），解析出一个整数
123
>>> int("123abc")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '123abc'
>>> int("AD", 16) # 将数字字符串进行十六进制解析，结果都是十进制
173
# 10*16^1 + 13*16^0 = 173
>>> int("91A", 12)
1318
>>> 10 * 12 ** 0 + 1 * 12 ** 1 + 9 * 12 ** 2
1318
>>> int("A1F", 13)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 13: 'A1F'
>>> int("91a", 100)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: int() base must be >= 2 and <= 36, or 0
base 进制基数 = [2, 36]
>>> int("98*!",12) # 出现特殊符号
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 12: '98*!'
>>> int("10010101") # 注意坑 二进制串特不一定是二进制数字
10010101
>>> int("10010101", 2)
149

float() ：将其他的数据转为小数

>>> float(3)
3.0
>>> float(3.14)
3.14
>>> float("3.14")
3.14
>>> float("3.14", 10)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: float expected at most 1 argument, got 2

str() ：将其他数据转字符串

>>> str(123)
'123'
>>> str(3.14)
'3.14'
>>> str(print)
'<built-in function print>'

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

# 对于数值类型的话 非0全是True 0就是False
>>> bool(1)
True
>>> bool(-1)
True
>>> bool(0)
False
>>> bool(3.14)
True
>>> bool(-3.14)
True
>>> bool(0.0)
False
# 对字符串 空串为False 非空为True
>>> bool("abc")
True
>>> bool("") #空串
False

进制转换

>>> bin(123) # 转二进制字符串
'0b1111011'
>>> oct(123) # 转八进制字符串
'0o173'
>>> hex(123) # 转十六进制字符串
'0x7b'
>>> bin("123") # 参数必须是整数
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object cannot be interpreted as an integer
>>> bin(3.14)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'float' object cannot be interpreted as an integer

字符与ASCII码转换

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

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

>>> ord('a')
97
>>> ord('A')
65
>>> ord('0')
48

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

>>> chr(98)
'b'
>>> chr(57)
'9'

A = 10 B = 11 ...... F = 15

13 = D

chr(ord('A') + 13 - 10)

常见的数学计算

>>> abs(3.14) # 取绝对值
3.14
>>> abs(-3.14)
3.14
>>> pow(2, 4) # 求a 的 b 次幂
16
>>> pow(2.0, 4)
16.0
>>> pow(16, 0.5)
4.0
>>> max(1, 2, 3, 4) # 求最值问题
4
>>> min(1,2,3,4)
1
>>> round(3.14) #四舍五入
3
>>> round(3.51)
4

六、输入与输出

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)
"""
这是最常见的方式，适用于输入的数据之间由某个分隔符（如空格、逗号、制表符等）隔开的情况。
用户在一行内输入所有数据，程序通过 input() 获取整个字符串，
再使用 split() 方法将字符串按指定分隔符切割成一个列表。
"""
numbers_str = input("请输入一组用空格分隔的整数：")
numbers = list(map(int, numbers_str.split()))

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
>>> "123" + "456"
'123456'

• 减法：数值相减
• 乘法：数值相乘，序列增倍

>>> 3 * 6
18
>>> "我爱你" * 3
'我爱你我爱你我爱你'

• 除法：小数除 /，整数除 //

整数除 只要两边都是整数 结果一律为整数 但凡有一个小数 结果就是小数（只有整数位，小数位都为0）

>>> 10 / 2
5.0
>>> 10 // 2
5
>>> 10 / 3
3.3333333333333335
>>> 10 // 3
3
>>> 10.0 // 3
3.0
>>> 10.5 // 3
3.0

• 幂运算

>>> 2 ** 3
8
>>> 16 ** 0.5
4.0

• 取余：10 / 3 = 3 ~ 1

>>> 10 % 3
1

取余经常用于哪些场景，带有数据重复或循环的情况

• 22日对应周五，22 % 7 = 1 余数为1 则对应周五 0 对应周四....
• 30 % 7 = 2 对应周六

布尔判断运算符

运算结果一律为布尔值

>  <  >=  <=  !=   ==

Python允许连续比较

>>> 1 < 2 < 3
True
>>> 1 < 2 and 2 < 3
True

在 Python 当中 == 到底比得是啥？

比的是具体对象的值

>>> a = 1
>>> b = 1
>>> id(a) # id 取变量中存储的数据对象在内存中的地址
140715464473016
>>> id(b)
140715464473016
>>> a = 1000
>>> b = 1000
>>> id(a)
3267440575376
>>> id(b)
3267440589968
"""
可以发现a和b在为1000时 对象地址不一样？
因为在Python当中 只有-5~256 Python会自动创建这些数据对象，提供给调用者使用
也就意味着如果创建该范围之外的数据对象的话，Python则重新创建新的对象出来
a = 1000, b = 1000 其实是两个1000数据的对象
a == b 比的是对象的内容 但是a和b存的地址不一样
a = 1, b = 1, 其实只有一个 1 数据的对象
a == b 比的是对象的内容 但是a和b存的地址一样
"""

增强型赋值运算符

+= -= *= /= //= **= %=
a += 2
a = a + 2
b **= 2
b = b ** 2

在 Python 中 是不存在 ++ -- 这种自增运算符的！

int i = 1;
i++;
System.out.println(i);//2
System.out.println(i++);//2
int j = i++;
System.out.println(i);//4
System.out.println(j);//3
i = i++;
System.out.println(i);//4
i = i++;
System.out.println(i);//4

i++ 流程

1. 开辟临时存储区

2. 将 i 的值复制到临时存储区内

3. i 自身 +1

4. 临时存储区的值等待被调用（输出 赋值 参与运算）

System.out.println(x++ + ++x + ++x + x++); // 12
System.out.println(x); // 5

 逻辑运算符

与 或 非 = and or not （ && || ! ）

与：全真则真 有假则假

或：有真则真 全假则假

非：取反

>>> 1 < 2 and 2 < 3
True
>>> 1 < 2 or 2 > 3
True
>>> not 1 < 2
False

& 与 && 的区别

int x = 0;

int y = 0;

System.out.println(x++ < 0 & y ++ < 0); // 无论左边是否为假 右边都要计算

System.out.println(x); //1

System.out.println(y); //1

int x = 0;

int y = 0;

System.out.println(x++ < 0 && y ++ < 0); // 如果左边是假 右边不计算

System.out.println(x); //1

System.out.println(y); //0

&& 就是为了避免一些没有必要的计算 提高效率

 位运算符

&按位与
>>> 13 & 7
5
1101
0111
0101 = 5
|按位或
>>> 13 | 7
15
1101
0111
1111 = 15
>> 右移
>>> 16 >> 2
10000
100|00
100 = 4
16 / 2 ^ 2
<< 左移
>>> 2 << 3
16
0010
0010000
10000 = 16
2 * 2 ^ 3
~取反 符号取反再减1
>>> ~15
-16
01111 = 15
10000 = -16
^ 异或：相等为假 不同为真
>>> 13 ^ 7
10
1101
0111
1010 = 10

关于变量交换值

a = 1
b = 3
temp = a
a = b
b = temp
a, b = b, a # Python自带的交换特点
只针对整数
a = 10
b = 100
a = a + b # 110
b = a - b # 10
a = a - b # 100
只针对整数
a = a ^ b
b = a ^ b
a = a ^ b

成员运算符

in 和 not in

判断一个元素是否在另一个序列中

>>> "abc" in "sakjdgjhsgadugashjdvasvdjgsa"
False
>>> "abc" in "sakjdgabca"
True
>>> 1 in [2,3,4]
False

从属/身份运算符

is 和 not is

判断两个变量指向的对象是否是同一个对象（比地址）

>>> a = 1
>>> b = 1
>>> a == b
True
>>> a is b
True
>>> a == 1000
False
>>> a = 1000
>>> b = 1000
>>> a == b
True
>>> a is b
False
>>> a = "abc" # 字符串
>>> b = "abc" # 之前已经创建了"abc" 这里直接复用 而不是重新创建 跟整数是有区别的
>>> a == b
True
>>> a is b
True
>>> id(a)
140715463387184
>>> id(b)
140715463387184

八、条件判断

只有 if-else 语句， Python 不支持 switch 语句

if condition:
    # 如果条件为真，则执行这里的代码块
    # 这里可以是一行代码或多行代码
elif another_condition:
    # 如果第一个条件不满足，但第二个条件为真，则执行这里的代码块
    # 可以有零个或多个elif部分
else:
    # 如果以上条件都不满足，则执行这里的代码块
    # else部分是可选的

#示例
x = 10

if x > 0:
    print("x is positive")
elif x == 0:
    print("x is zero")
else:
    print("x is negative")
#在这个示例中，如果x大于0，则打印“x is positive”，如果x等于0，则打印“x is zero”，否则打印“x is negative”。
#除了基本的条件判断外，Python还支持使用逻辑运算符（如and、or、not）来组合条件。例如：
x = 5
y = 10

if x > 0 and y > 0:
    print("Both x and y are positive")

if x > 0 or y > 0:
    print("At least one of x and y is positive")

if not x == 0:
    print("x is not zero")

九、循环语句

主要解决什么样的问题：具有重复性、规律性的问题

向前走 10 步：有明显的循环次数的 - for

向前走，直到碰墙为止：没有明显的循环次数的，但是有结束条件 - while

循环四要素：

• 循环的开始（从第1步开始；从第1步开始/从起点开始）
• 循环的继续条件（还没走到第10步；没有碰到墙/就是看距离）
• 循环体（走的每一步；走的每一步）
• 循环的步长/间隔/周期/进度（步数的统计；距离的统计）

//打印1~100
for (①int i = 1; ②i <= 100; ④i++) {
③System.out.println(i);
}
①->②->③->④->②->③->④->②->③->④->②不满足为止
int i = 1;
for (;i <= 100;) {
System.out.println(i);
i++;
}
==>
int i = 1;
while (i <= 100) {
System.out.println(i);
i++;
}

for i in range(11):
print(i)
"""
range(n) : 取值范围是[0,n) 步长默认为1
0 1 2 3 4 5 6 7 8 9 10
i
循环的开始：0
循环的继续条件：i < n
循环体：print(i)
循环的步长:步长默认为1
"""
for i in range(2, 10):
print(i)
"""
range(a, b):取值范围[a, b) 步长默认1
"""
for i in range(2, 13, 2):
print(i)
"""
range(a, b, c):取值范围[a, b) 步长默认2
"""
print("="*12)
for i in range(100, 1):
print(i)
for i in range(100, 10, -10):
print(i)
"""
range(a,b,c)
如果c > 0, a < b 才是有效范围 递增
如果c < 0, a > b 才是有效范围 递减
"""
# 特殊的 结合序列去使用 遍历序列中每一个元素
for i in "abcdefg":
print(i)
"""
******
******
******
******
******
"""
for i in range(5):
print("******")
print("=" * 10)
for i in range(5):
for j in range(6):
print("*", end = "")
print()
print("=" * 10)
"""
*
**
***
****
*****
******
"""
for n in range(6):
for i in range(n):
print("*", end = "")
print()

十、列表

序列

序列是指一组有序的数据集合，其本质是一块存储多个值的连续内存空间。每个值在序列中都有对应的位置编号，即索引，这些值具有一定的顺序，可以通过索引访问对应的值。序列不是一种特定的数据类型，而是一种存储数据的方式。

字符串、元组、列表、集合、字典都可以归属于序列。

序列通用操作

索引 /角标：通过元素的索引访问序列中的特定元素。

>>> arr = [1,2,3,4,5,6,7,8,9]
>>> arr[0]
1
>>> arr[8]
9
>>> arr[-1] # 倒数第1个
9
>>> arr[-2] # 倒数第2个
8
>>> arr[-100]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> arr[100]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range

切片：访问一定范围的序列元素，格式为 name[start:end:step]。 跟 range(a, b, c) 基本类似

>>> arr[2:] # 从角标2开始向尾遍历 步长为1
[3, 4, 5, 6, 7, 8, 9]
>>> arr[2::2] # 从角标2开始向尾遍历 步长为2
[3, 5, 7, 9]
>>> arr[:6] # 从头开始到角标6(不取) 步长为1
[1, 2, 3, 4, 5, 6]
>>> arr[:6:3] # 从头开始到角标6(不取) 步长为3
[1, 4]
>>> arr[:] # 从头到尾
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[::]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[::2]
[1, 3, 5, 7, 9]
=======================================特殊的
>>> arr[-1:-7] # 从尾到头 步长必须负数
[]
>>> arr[-1:-7:-1]
[9, 8, 7, 6, 5, 4]
>>> arr[-9:7] # 从头到尾 步长为正数
[1, 2, 3, 4, 5, 6, 7]
>>> arr[0:7]
[1, 2, 3, 4, 5, 6, 7]
>>> arr[-9:-2] # 从头到尾 步长为正数
[1, 2, 3, 4, 5, 6, 7]

相加：实现相同类型的序列相加，即直接在后面连接。

list1 = [1, 2, 3]  
list2 = [4, 5, 6]  
  
# 将两个列表相加  
combined_list = list1 + list2  
print(combined_list)  # 输出: [1, 2, 3, 4, 5, 6]

tuple1 = (1, 2, 3)  
tuple2 = (4, 5, 6)  
  
# 将两个元组相加  
combined_tuple = tuple1 + tuple2  
print(combined_tuple)  # 输出: (1, 2, 3, 4, 5, 6)

string1 = "Hello, "  
string2 = "world!"  
  
# 将两个字符串相加（拼接）  
combined_string = string1 + string2  
print(combined_string)  # 输出: Hello, world!

乘法：重复n次的序列。

list1 = [1, 2, 3]  
  
# 将列表重复两次  
repeated_list = list1 * 2  
print(repeated_list)  # 输出: [1, 2, 3, 1, 2, 3]

tuple1 = (1, 2, 3)  
  
# 将元组重复两次  
repeated_tuple = tuple1 * 2  
print(repeated_tuple)  # 输出: (1, 2, 3, 1, 2, 3)

string1 = "Hi "  
  
# 将字符串重复三次  
repeated_string = string1 * 3  
print(repeated_string)  # 输出: Hi Hi Hi

成员资格

>>> arr = [1,2,3,4,5,6,7,8,9]
>>> 1 in arr
True
>>> 10 in arr
False

长度与最值

>>> arr = [1,2,3,4,5,6,7,8,9]
>>> len(arr) # 获取序列的长度
9
>>> len(arr)
9
>>> max(arr)
9
>>> min(arr)
1
>>> s = "ABC"
>>> len(s)
3
>>> max(s)
'C'
>>> min(s)
'A'

常见操作

创建问题

"""
列表
1.存储多个数据 数据不一定都是同一个类型 但是为了方便操作 建议存一样的类型
2.可以通过索引/角标来访问元素
3.可变长的数组 我们后续可以在列表中进行 增 删
4.用一对中括号[]
"""
# 创建一个空的列表
arr = []
print(arr)
# 创建一个具有若干元素的列表
arr = [1, 2, 3, 4]
print(arr)
# 创建一个具有长度但是没有值的列表
arr = [None] * 5
print(arr)
# 通过【列表推导式/解析式】来进行创建
# [目标值表达式 for 目标值 in 迭代对象 if ....]
# 创建1~100当中 能够被3整除 且 能够被5整除 的所有数字
"""
for x in range(1, 101):
if x % 3 == 0 and x % 5 == 0:
print(x)
"""
arr = [x for x in range(1, 101) if x % 3 == 0 and x % 5 == 0]
print(arr)
# 创建1~100当中 偶数
arr = [x for x in range(1, 101) if x % 2 == 0]
print(arr)
# 水仙花数
for num in range(100, 1000):
a = num % 10
b = num // 10 % 10
c = num // 100
if a ** 3 + b ** 3 + c ** 3 == num:
print(num)
arr = [num for num in range(100, 1000) if (num % 10) ** 3 + (num // 10 % 10) **
3 + (num // 100) ** 3 == num]
print(arr)
arr = [x * 3 + "哈哈" for x in "ABCDEFG"]
print(arr)
# 通过输入来获取元素
"""
5
"1" "2" "3" "4" "5"
"""
n = eval(input())
arr = input().split(" ") # 将输入的数据以空格分割 分割的结果就是列表
print(arr)
arr = [int(x) for x in arr]
print(arr)

遍历问题

arr = [1,2,3,4,5,6,7,8,9]
# 通过角标遍历
for i in range(len(arr)):
    print(arr[i])
# 通过foreach遍历
for num in arr:
    print(num)

添加问题

my_list.append(6)  
print(my_list)  # 输出: [10, 2, 3, 4, 5, 6]

my_list.insert(1, 'a')  
print(my_list)  # 输出: [10, 'a', 2, 3, 4, 5, 6]

another_list = [7, 8, 9]  
my_list.extend(another_list)  
print(my_list)  # 输出: [10, 'a', 2, 3, 4, 5, 6, 7, 8, 9]

删除问题

my_list.remove(2)  
print(my_list)  # 输出可能是: [10, 'a', 3, 4, 5, 6, 7, 8, 9]（注意：顺序可能因 Python 版本和列表内容而异）

element = my_list.pop(1)  
print(element)  # 输出: 'a'  
print(my_list)  # 输出可能是: [10, 3, 4, 5, 6, 7, 8, 9]

del my_list[0]  
print(my_list)  # 输出可能是: [3, 4, 5, 6, 7, 8, 9]

排序问题

my_list.sort()  # 升序排序  
print(my_list)  # 输出: [3, 4, 5, 6, 7, 8, 9]  
my_list.sort(reverse=True)  # 降序排序  
print(my_list)  # 输出: [9, 8, 7, 6, 5, 4, 3]

最值问题

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)

存在性问题

arr = [1,2,3,4,5,4,6,4,7,8,9]
# 元素是否存在
key = 10
for num in arr:
    if num == key:
        print("存在")
        break
else:
    print("不存在")
# 元素在哪个位置 从左到右第1次出现的角标 不存在返回-1
key = -4
index = 0
for i in range(len(arr)):
    if arr[i] == key:
        index = i
        break
else:
    index = -1
print(index)

翻转问题

arr = [1,2,3,4,5,6,7,8,9,10]
#      0 1 2 3 4 5 6 7 8 9 角标
arr = arr[-1::-1]
print(arr)

for i in range(0, len(arr) // 2):
    j = len(arr) - 1 - i
    arr[i], arr[j] = arr[j], arr[i]
print(arr)

left = 0
right = len(arr) - 1
while left <= right:
    arr[left], arr[right] = arr[right], arr[left]
    left += 1
    right -= 1
print(arr)

排序算法

选择排序

arr = [9,2,4,7,3,6,5,1,8]
for i in range(len(arr) - 1): # -1是指少比较一轮
    for j in range(i + 1,len(arr)):
        if arr[i] > arr[j]:
            arr[i], arr[j] = arr[j], arr[i]
print(arr)

冒泡排序

arr = [13, 4, 8, 10, 1, 2, 7, 11, 9]
for i in range(len(arr) - 1): #少比较一轮
    for j in range(len(arr) - i - 1): #-1是为了防止j + 1越界
        if arr[j] > arr[j + 1]:
            arr[j], arr[j + 1] = arr[j + 1], arr[j]
print(arr)

插入排序

arr = [6, 7, 4, 3, 5, 8, 9, 2, 1]
#从第二个元素开始到最后一个元素
for i in range(1,len(arr)):
    #将这个元素先存入在e中
    e = arr[i]
    j = i
    while j > 0 and arr[j - 1] > e:
        arr[j] = arr[j - 1]
        j -= 1
    arr[j] = e
print(arr)

希尔排序

快速排序

堆排序

归并排序

计数排序

arr = [8,2,1,4,8,7,9,2,3,4]
minValue = min(arr)
maxValue = max(arr)
temp = [0] * (maxValue - minValue + 1)
for i in range(len(arr)):
    temp[arr[i] - minValue] += 1

k = 0
for j in range(len(temp)):
    while temp[j] > 0:
        arr[k] = j + minValue
        temp[j] -= 1
        k += 1
print(arr)

基数排序

桶排序

查找算法

二分查找：要求数据必须有序，只需要考虑数据所在的位置即下标。

arr = [1,2,3,4,5,6,7,8,9]
minIndex = 0
maxIndex = len(arr) - 1
midIndex = (minIndex + maxIndex) // 2
key = 8
while arr[midIndex] != key:
    if arr[midIndex] < key:
        minIndex = midIndex + 1
    else:
        maxIndex = midIndex - 1
    if minIndex > maxIndex:
        midIndex = -1
        break
    midIndex = (minIndex + maxIndex) // 2
print(midIndex)

插值查找：要求数据必须有序，不仅要考虑数据的位置还要考虑数据的分布情况。

注意：适用于均匀分布的数据。

arr = [1,3,4,5,10,22,33,35,45,50]
#设置最小角标
low = 0
#设置最大角标
high = len(arr) - 1
#设置偏移量的角标
mid = 0
key = 51
#计算偏移量
mid = int((key - arr[low]) / (arr[high] - arr[low]) * (high - low)) + low
while True:
    #判断是否越界
    if mid > high or mid < low:
        mid = -1
        break
    #在数组内找不到
    if low > high:
        mid = -1
        break
    #偏移量角标对应的值与目标值相等，退出循环
    if arr[mid] == key:
        break
    #如果偏移量角标对应的值大于目标值，则重新定义最大角标
    elif arr[mid] > key:
        high = mid - 1
    #如果偏移量角标对应的值小于目标值，则重新定义最小角标
    else:
        low = mid + 1
print(mid)

斐波那契查找

列表对象函数

对象函数是区别于内置函数的，内置函数直接调用即可 len() max()

对象函数 必须通过某一个具体的对象来调用 列表 . 函数名 ()

# append()
# 将某一个元素对象添加在列表的表尾
# 如果添加的是其他的序列，该序列也会被看成是一个数据对象
arr = [1,2,3,4]
arr.append(5)
print(arr)
arr2 = [6,7,8]
arr.append(arr2)
print(arr)
# count()
# 统计列表当中 某一个元素出现的次数
arr = [1,2,3,4,1,2,3,1,1,2,0,0,1]
print(arr.count(1))
# extend()
# 在当前列表中 将传入的其他序列的元素添加在表尾
arr1 = [1,2,3]
arr2 = [4,5,6]
arr1.extend(arr2)
print(arr1)
"""
arr1.extend(7)
TypeError: 'int' object is not iterable(可迭代的=序列)
"""
arr1.extend("ABC")
print(arr1)
# index()
# 查找(从左到右)元素第一次出现的位置(角标)
arr = [1,2,3,4,5,6,7,4,5,6,9]
print(arr.index(4))
print(arr.index(4, 5, 8)) #[5, 8) 区间中找4的角标
"""
print(arr.index(10))
ValueError: 10 is not in list 找不到则报错
"""
# insert(index, obj)
# 在某一个角标出处插入一个元素
arr = [1,2,3,4]
arr.insert(2, 5)
print(arr)
# pop()
# 弹栈：删除最后一个元素 并返回其值
# 也可以删除指定角标处的元素
arr = [1,2,3,4]
print(arr.pop())
print(arr)
print(arr.pop(1))
print(arr)
# remove()
# 移除指定元素 从左到右第一次出现的
arr = [1,2,3,4,2,3,4,2,3,4]
arr.remove(4)
print(arr)
# reverse()
# 翻转列表
arr = [1,2,3,4]
arr.reverse()
print(arr)
# sort()
# 排序
arr = [4,2,5,2,6,2,7,9,4,7,2,7]
# arr.sort() # 默认升序
arr.sort(reverse = True) # 降序
arr = ["ABC", "123123123","我爱你中国","123123123","kasdkjas"]
arr.sort(key = len) # 以序列的长度为基准进行排序
print(arr)
# clear()
# 清空
arr = [1,2,3,4]
arr.clear()
print(arr)
# copy()
# 复制一个列表(浅拷贝)
arr1 = [1,2,3,4]
arr2 = arr1.copy()
print(arr1 == arr2) # True 比较的是内容
print(arr1 is arr2) # False 比较的是对象地址
print(arr1)
print(arr2)
arr1[0] = 5
print(arr2[0])
# 上述代码在arr1中修改元素 并不影响arr2
arr1 = [1,2,3,[4,5,6]]
arr2 = arr1.copy()
arr2[0] = 7
print(arr1[0])
print(arr2[0])
arr2[3][0] = 666
print(arr1[3])
# 上述代码在arr2中修改元素 影响arr1
arr2[3] = [9,9,9]
print(arr1[3])
print(arr2[3])
# 额外的知识
# del关键字：删除
arr = [1,2,3,4]
del arr[0] # 删除序列中的元素
print(arr)
del arr # 删除变量
"""
NameError: name 'arr' is not defined. Did you mean: 'arr2'?
print(arr)
"""

字符串对象函数

可变对象与不可变对象

列表是可变对象：可以修改列表中的元素 甚至长度

字符串是不可变对象：不可以修改字符串中的元素 包括 长度

注意：也就意味着对字符串的修改 一律不是在本身修改 而是创建一个新的字符串！

>>> arr = [1,2,3]
>>> arr[0] = 4
>>> arr
[4, 2, 3]
>>> s = "ABC"
>>> s[0]
'A'
>>> s[0] = "D"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
字符串对象不支持元素修改

 字符串常用相关函数

# center()
# 指定填充字符 将目标字符进行居中
s1 = "ABC"
s2 = s1.center(10,"#")
print(s1)
print(s2)
# count()
# 和列表的count相似 统计字符串的个数
s = "abchjghjabcjkhjkhabchkjhabc"
print(s.count("abc"))
print(s.count("a"))
# count是非贪心统计 贪心统计6个
s = "AAAAAAAA"
print(s.count("AAA"))
print(s.count("AAA",2,6))
# endswith()
# 过滤字符串结尾 同样也可以指定区间
s = "泷泽萝拉.avi"
print(s.endswith(".avi"))
# find()
# 寻找字符串第一次出现的位置 同样也可以指定区间
s = "八百标兵奔北坡"
print(s.find("标兵")) # 2 指定是标的角标
# format()
# 格式化输出
name = "小强"
age = 18
print("我的名字叫%s, 年龄%d岁" % (name, age))
print("我的名字叫{}, 年龄{}岁".format(name, age))
print(f"我的名字叫{name}, 年龄{age}岁")
print(f"我的名字叫{3 > 2}, 年龄{2 ** 8}岁")
# index()
# 寻找字符串第一次出现的位置 同样也可以指定区间
s = "八百标兵奔北坡"
print(s.index("标兵")) # 2 指定是标的角标
s = "ABC"
print(s.find("D")) # -1 如果找不到 则返回-1
# print(s.index("D"))# 如果找不到 直接报错 ValueError: substring not found
# isalnum()
# 判断是否是字母或数字字符串 al-alpha 字母 num-number 数字
print("abc".isalnum())
print("123".isalnum())
print("abc123".isalnum())
print("abc123^&%&^&".isalnum())
# isalpha() 是否是纯字母字符串
# isdecimal() 是否是十进制纯数字字符串
# isdigit() 是否是纯数字字符串
# isspace() 是否是纯空格字符串
# islower() 出现的字母是否是小写字母
print("123abc".islower())
print("123Abc".islower())
# isupper() 出现的字母是否是大写字母
# join() 将字符串列表进行拼接的
arr = ["banana", "orange", "apple","pich"]
s = "-".join(arr)
print(s)
# ljust()左对齐 rjust()右对齐
print("ABC".ljust(10, "#"))
print("ABC".rjust(10, "#"))
# lower()出现的大写字母转小写 upper() 相反
print("Hello World123".lower())
# lstrip()去除左边空格 rstrip()去除右边空格
print(" ABC ".lstrip())
print(" ABC ".rstrip())
print(" ABC ".strip()) # 两边都去掉连续空格
print(" A B C ".strip())
# replace(a,b) 替换 a旧 b新
s = "宇智波佐助、宇智波斑、宇智波鼬、宇智波泉奈、宇智波止水、宇智波卡卡西"
s1 = s.replace("宇智波","千手")
print(s)
print(s1)
# split() 以某一个分割符来切割字符串 结果是一个字符串的列表
s = "泰罗-杰克-赛文-迪迦-梦比优斯"
arr = s.split("-")
print(arr)
arr = "1 2 34 4.12".split(" ")
print(arr)

字符串创建和转换

• str(): 将对象转换为字符串。
• bytes(): 返回一个字节对象。
• bytearray(): 返回一个可变字节数组。
• chr(): 返回给定整数的Unicode字符。
• ord(): 返回Unicode字符的整数表示。

字符串长度和检查

• len(): 返回字符串的长度。
• isalpha(): 如果字符串只包含字母并且非空，则返回True。
• isdigit(): 如果字符串只包含数字并且非空，则返回True。
• isalnum(): 如果字符串只包含字母和数字并且非空，则返回True。
• isspace(): 如果字符串只包含空白字符并且非空，则返回True。
• islower(): 如果字符串至少包含一个区分大小写的字符，并且所有这样的字符都是小写，则返回True。
• isupper(): 如果字符串至少包含一个区分大小写的字符，并且所有这样的字符都是大写，则返回True。

字符串修改

• capitalize(): 将字符串的首字母转换为大写，其余字母转换为小写。
• title(): 返回标题化的字符串，即所有单词的首字母大写，其余字母小写。
• swapcase(): 交换字符串中的大小写字母。
• upper(): 将字符串转换为大写。
• lower(): 将字符串转换为小写。
• ljust(), rjust(), center(): 对字符串进行填充并返回新的字符串。
• strip(), lstrip(), rstrip(): 去除字符串两侧的空白字符（或其他指定字符）。
• translate(): 返回通过给定转换表转换的字符串的副本。

字符串查找和替换

• find(), index(): 查找子字符串并返回其索引，如果未找到则find()返回-1，而index()会引发ValueError异常。
• replace(): 返回字符串的副本，其中的所有旧子字符串都被新子字符串替换。
• split(), rsplit(), partition(), rpartition(), splitlines(): 将字符串分割为子字符串列表。

字符串连接和格式化

• join(): 将序列中的元素以指定的字符连接生成一个新的字符串。
• format(): 格式化字符串，可以替换字符串中的占位符。
• f-string（格式化字符串字面量）：从Python 3.6开始，可以使用f-string进行更简洁的字符串格式化。

math相关函数

#数论与表示函数
math.floor(x) #返回不大于 x 的最大整数（向下取整）
math.ceil(x) #返回不小于 x 的最小整数（向上取整）。
math.trunc(x) #返回 x 的整数部分，去掉小数点后的部分。
math.isfinite(x) #判断 x 是否为有限数（非无穷大或非NaN）。
math.isinf(x) #判断 x 是否为无穷大（正无穷或负无穷）。
math.isnan(x) #判断 x 是否为 NaN（Not a Number）。
#幂数与对数函数
math.pow(x, y) #计算 x 的 y 次方（等同于 x ** y）。
math.sqrt(x) #计算 x 的平方根。
math.cbrt(x) #计算 x 的立方根。
math.exp(x) #计算自然指数 e 的 x 次方（即 e^x）。
math.log(x[, base]) #计算 x 的自然对数（默认以 e 为底），如果提供了 base 参数，则计算以 base 为底的对数。
math.log2(x) #计算 x 以2为底的对数。
math.log10(x) #计算 x 以10为底的对数。
math.log1p(x) #计算 log(1 + x)，对于较小的 x 提供更高的精确度。
#三角函数与反三角函数
math.sin(x) #计算 x（以弧度为单位）的正弦值。
math.cos(x) #计算 x（以弧度为单位）的余弦值。
math.tan(x) #计算 x（以弧度为单位）的正切值。
math.asin(x) #计算正弦值为 x 的角度（以弧度为单位）的反正弦（主值）。
math.acos(x) #计算余弦值为 x 的角度（以弧度为单位）的反余弦（主值）。
math.atan(x) #计算正切值为 x 的角度（以弧度为单位）的反正切（主值）。
math.atan2(y, x) #计算直角坐标 (x, y) 对应的极坐标角度（以弧度为单位），范围 -π 到 π。
#双曲函数
math.sinh(x) #计算 x 的双曲正弦值。
math.cosh(x) #计算 x 的双曲余弦值。
math.tanh(x) #计算 x 的双曲正切值。
math.asinh(x) #计算 x 的反双曲正弦值。
math.acosh(x) #计算 x 的反双曲余弦值，要求 x >= 1。
math.atanh(x) #计算 x 的反双曲正切值，要求 -1 < x < 1。
#特殊函数与常量
math.erf(x) #计算 x 的误差函数值。
math.gamma(x) #计算 x 的伽马函数值。
math.lgamma(x) #计算 x 的自然对数伽马函数值。
math.factorial(n) #计算整数 n 的阶乘。
math.comb(n, k) #计算从 n 个不同元素中取出 k 个元素的组合数。
math.perm(n, k) #计算从 n 个不同元素中取出 k 个元素的排列数。
math.gcd(a, b) #计算整数 a 和 b 的最大公约数。
math.isqrt(n) #返回不大于 n 的最大整数平方根。
math.dist(p, q) #计算两点 p 和 q 之间的欧氏距离（在二维或三维空间中）。
#常量
math.pi #圆周率，约等于 3.141592653589793。
math.e #自然对数的底数，约等于 2.718281828459045。
math.tau #数学常数 τ，等于 2π，约等于 6.283185307179586。
math.inf #正无穷大。
math.nan #特殊浮点数，表示 "Not a Number"。

Random相关函数

1. random.random(): 返回一个浮点数，范围在 [0.0, 1.0) 之间。
2. random.randint(a, b): 返回一个指定范围内的整数，包括边界值。
3. random.choice(seq): 从非空序列中随机选择一个元素。
4. random.shuffle(x): 随机打乱列表中元素的顺序。
5. random.sample(population, k): 从指定的序列中随机选择 k 个独立的元素。

import random

random.random()

random.randint(1, 10)

my_list = [1, 2, 3, 4, 5]
random.choice(my_list)

my_list = [1, 2, 3, 4, 5]
random.shuffle(my_list)

my_list = [1, 2, 3, 4, 5]
random.sample(my_list, 3)

列表字符串编程练习

Demo53

# 关于字符串匹配：KMP算法
# 本代码仅非贪暴力解
s1 = input()
s2 = input()
count = 0
i = 0
while i <= len(s1) - len(s2):
    if s1[i] == s2[0]:
        j = i + 1
    for k in range(1, len(s2)):
        if s1[j] != s2[k]:
            i += 1
            break
        j += 1
    else:
        count += 1
        i = j
    else:
        i += 1
print(count)

Demo54

s1 = input()
s2 = input()
length = len(s2)
while length > 0:
    left = 0
    right = length - 1
    while right < len(s2):
        s = s2[left : right + 1]
        if s in s1:
            print(s)
            exit() # 退出程序
        left += 1
        right += 1
    length -= 1