Python基础（这一篇就够了）

1.基础篇

1.1课程定位

• Web开发：

Python提供了一系列强大的Web框架，如Django和Flask，使得开发者能够高效地构建复杂的Web应用程序。这些框架自带众多特性，包括URL路由、模板渲染、数据库操作等，极大地简化了Web开发流程。

• 数据科学与数据分析：

Python拥有numpy、pandas、matplotlib、scikit-learn、TensorFlow、PyTorch等大量用于数据处理、分析、可视化及机器学习的库，使其成为数据科学家和分析师的首选工具之一。

• 自动化脚本与系统管理：

由于Python的易读性和简洁性，它被广泛用于编写各种自动化脚本，如系统维护、网络脚本、文件管理等。Python的os、subprocess、shutil等模块允许对操作系统进行高级操作。

• 科学计算与工程计算：

在科学计算领域，Python结合NumPy、SciPy等库，可以进行数值计算、模拟、信号处理等工作。

• 网络爬虫：

Python的requests、BeautifulSoup、Scrapy等库支持开发高效的数据抓取工具，便于从互联网上大规模获取并处理数据。

• 桌面应用程序开发：

使用Tkinter、wxPython、PyQt等图形用户界面(GUI)工具包，Python可以创建跨平台的桌面应用程序。

• 后端服务和API开发：

Python可以轻松构建RESTful API服务，并通过诸如FastAPI、Flask-RESTful等库提供高性能的微服务。

• 教育与入门编程：

Python语法简单清晰，适合初学者入门，也是许多学校和教育机构教授编程的基础语言。

• 云计算和运维：

在云计算环境中，Python常用于编写部署脚本、配置管理工具（如Ansible）、与AWS、Google Cloud、Azure等云平台API进行交互。

• 游戏开发：

虽然不是主流的游戏开发语言，Python仍然可以通过pygame等库进行简单的2D游戏开发。

1.2学习方法

• 没有一个冬天不可逾越，没有一个春天不会到来，做一个轻松的工程师
•  高数学得好有什么用？答：忘得慢一些。
• 那编程学得好有什么用？答：同上。故此，菜就要多练！
• 推荐题集LeetCode

1.3软件概述

• 软件的定义：
  是指一些按照特定顺序组织的能够被计算机识别的数据与指令的集合
  在解决问题的时候，一定要先分析问题（把解决问题的步骤先一步一步列出来，然后再利用编程语言进行编码）
• 软件的分类：
  操作系统软件： Windows Android IOS Harmony
  主要负责管理和调控计算机硬件，给用户提供最基本的计算机功能（磁盘管理，上网管理，内存管理，
  用户管理 ...... ）
  应用软件：微信 优酷 支付宝 网易云
  提供专业领域服务的软件，是基于操作系统软件运行的
• 编程语言
  机器语言：所有的数据都是由 0 和 1 组成，人看不懂，机器能看懂
  汇编语言： 1 2 add ，必须要考虑计算机的执行过程，门槛比较高
  高级语言： C C++ Java Python JavaScript.... ，以人类的角度设计的，对学习者非常友好，但是计算机就
  看不懂了

  进阶知识：

  静态编译型：C  C++  java

  动态解释型：python  javaScript  (脚本语言)

  静态与动态的区别：

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

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

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

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

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

  编译：将一本英文书翻译成中文书

  翻译：同声传译

1.4安装环境

Python 开发工具包

http://python.p2hp.com/downloads/windows/index.html

如何验证安装成功： win+R 输入 cmd 打开控制台 输入 python 命令

VSCode

https://code.visualstudio.com/

1.5脚本与交互

交互模式

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

弊端： 代码不能持久保存，代码随着窗口的关闭而消失

          

我们一般在做简单的代码演示、测试会使用到交互模式

为了永久保存代码，需要脚本模式

脚本模式

打开 VSCode ， File ， New Folder ，选择代码目录， New File 按钮创建文件，输入名称和后缀名 (.py)

注意：在VSCode中编写代码时要把 ctrl+s捏死

如何运行Python脚本文件呢 

打开 CMD 窗口，进入到代码目录路径

指令： python XXX.py 运行 XXX.py 文件

或者

找到Terminal中的New Terminal

1.6基本数据类型

讲数据类型前我们要先谈谈编程规范

• 标识符 

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

         规则：

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

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

         规范：

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

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

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

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

• 关键字

        就是一些单词，被Python赋予了特殊的含义，不能随便使用

>>> 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中单行注释为#        多行注释用"""   """

#这是单行注释

"""
这是多行注释
"""

 1 """
 2  *                             _ooOoo_
 3  *                            o8888888o
 4  *                            88" . "88
 5  *                            (| -_- |)
 6  *                            O\  =  /O
 7  *                         ____/`---'\____
 8  *                       .'  \\|     |//  `.
 9  *                      /  \\|||  :  |||//  \
10  *                     /  _||||| -:- |||||-  \
11  *                     |   | \\\  -  /// |   |
12  *                     | \_|  ''\---/''  |   |
13  *                     \  .-\__  `-`  ___/-. /
14  *                   ___`. .'  /--.--\  `. . __
15  *                ."" '<  `.___\_<|>_/___.'  >'"".
16  *               | | :  `- \`.;`\ _ /`;.`/ - ` : | |
17  *               \  \ `-.   \_ __\ /__ _/   .-` /  /
18  *          ======`-.____`-.___\_____/___.-`____.-'======
19  *                             `=---='
20  *          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
21  *                     佛祖保佑        永无BUG
22  *            佛曰:
23  *                   写字楼里写字间，写字间里程序员；
24  *                   程序人员写程序，又拿程序换酒钱。
25  *                   酒醒只在网上坐，酒醉还来网下眠；
26  *                   酒醉酒醒日复日，网上网下年复年。
27  *                   但愿老死电脑间，不愿鞠躬老板前；
28  *                   奔驰宝马贵者趣，公交自行程序员。
29  *                   别人笑我忒疯癫，我笑自己命太贱；
30  *                   不见满街漂亮妹，哪个归得程序员？
31 """

Python能够操作的数据都有哪些

• 常量
• 整数常量

        不能够改变的量-字面量

>>> print(10) #十进制
10
>>> print(0b1001) #二进制 binary
9
>>> print(0o12) #八进制 Oct...
10
>>> print(0x12) #十六进制 Hex...
18

注意：没有byte short long 之分 一律默认int  

• 小数常量

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

 注意：没有float与double之分 默认float

• 字符串常量

        字符串表示一段文本信息，程序会将文本信息原封不动的处理

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

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

>>> 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

True如果参与运算默认为1         False默认为0 

• 复数常量

        数学运算常用到

复数常量可以直接通过书写其标准形式 a + bj 创建，例如 3+4j，这在解释器中会被识别为一个复数类型的对象。同时，也可以通过 complex(a, b) 函数构造复数，其中 a 是实部，b 是虚部。复数的这种内建支持使得在实际编程过程中能够方便地对复数进行各种算术运算和其他数学操作

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

•  变量

        在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

补充：

• 内置函数名/类名

        内置函数就是Python自带的一些具有特殊功能的函数

>>> 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

1.7数据转换

1.7.1 int()

    将其他有效的数据转为整数

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

>>> int(3.14) # 将小数进行取整操作
3
>>> int("123") # 将数字字符串进行解析（默认十进制），解析出一个整数
123


>>> int("AD", 16) # 将数字字符串进行十六进制解析，结果都是十进制
173
# 10*1

>>> int("91A", 12)
1318
>>> 10 * 12 ** 0 + 1 * 12 ** 1 + 9 * 12 ** 2
1318
>>> int("A1F", 13)
Traceback (most recent call last):

>>> 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

 1.7.2 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

1.7.3 str()

        将其他数据转字符串  

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

1.7.4 bool()

        将其他数据转布尔类型 

>>> 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

注意：记住空串是False，简化编程 

 1.7.5 bin() oct() hex()

        进制转换

>>> 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

 1.7.6 ord() chr()

        字符与ASCII码转换

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

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

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

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

1.7.7 abs() pow() max() round()

        常见的数学计算

>>> 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
>>> round(3.123456 , 2) #四舍五入保留小数点后两位
3.12

round()在函数调用时返回要求保留两位小数就应使用给两个参数的“构造函数”--->

round(a , b)

1.8输入与输出

1.8.1 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)


a, b, c = map(int , input("请输入三个数中间用空隔分隔").split())

1.8.2 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.9运算符

1.9.1 算术运算符

• 加法：数值相加，序列拼接

>>> 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
1

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

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

30 % 7 = 2 对应周六

1.9.2 布尔判断运算符 

        运算结果一律为布尔值

        大于 小于 大于等于 小于等于 不等于 等于

> < >= <= != ==

  Python允许连续比较         

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

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

答：比的是具体对象的值

在Java中 == 比较的也是内容，对于引用数据类型的比较要用 equals() ，比较地址

>>> 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存的地址一样

1.9.3 增强型赋值运算符 

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

额外多说一句：在Python中 是不存在 ++ --这种自增运算符的！  

i++流程

1. 开辟临时存储区

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

3. i 自身 +1

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

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

1.9.4 逻辑运算符

与 或 非 = 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

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

1.9.5 位运符

&  |   >>  <<  ~  ^

&按位与
>>> 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

1.9.6 成员运算

in 和 not in

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

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

1.9.7 从属/身份运算符

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

1.10条件判断

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

# 单if语句
if 条件语句:
    条件为真时执行的内容


# if-else语句
if 条件语句:
    条件为真时执行的内容
else:
    条件为假时执行的内容


# if-elif语句 else if
if 条件语句1:
    条件语句1为真时执行的内容
elif 条件语句2:
    条件语句2为真时执行的内容
elif ....
else:
    所有条件都不满足时执行的内容


# 语句嵌套
if 条件1:
    if 条件2:
        执行内容(1和2都满足)
    else:
        执行内容(满足1不满足2)
else:
    执行内容(1和2都不满足)

1.11循环语句

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

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

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

循环四要素：

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

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)

•  ​​​​​循环嵌套

双层嵌套的循环中，外层循环控制打印的”行“，内层循环控制打印的”列“

若想要实现打印图形的左右对称，可以在内层循环中考虑用绝对值的思想

同理若要实现打印图形的上下对称，可以在外层循环中考虑用绝对值思想

n = eval(input("请输入层高"))

#外层循环控制行
for m in range (- n // 2 , n // 2 + 1):

    #内层循环对列进行把控
    for i in range(abs(m)):
        print("" , end = " ")
    for j in range(n // 2 + 1 - abs(m)):
        print("*" , end = " ")
    print()

•  特殊循环 for...else

# 回文素数
"""
题目描述
回文素数是指一个数既是素数又是回文数，例如131既是素数也是回文数
输出显示前100个回文素数，每行显示10个
"""

#我们从10开始遍历，找到第100个回文素数为止
# 我们可以采用for...else:的分支结构以简化—————哨兵模式

count = 0
num = 10
while count < 100:
    for i in range(2 , num // 2 + 1):
        if num % i == 0:
            break
    else:
        if str(num) == str(num)[::-1]:
            print(num , end = "\t")
            count += 1
            if count % 10 == 0:  #每多10个就换行
                print()
    num += 1

1.12数组列表

• 序列：存储一堆数据的集合/容器
• 序列的类型包括：列表、字符串、元组、集合、字典

1.12.1 序列概述

序列（Sequence）是指一种有序的数据结构，其中包含了一系列具有固定顺序的元素。每个元素在序列中都有一个确定的位置，可以通过索引进行访问

• 序列的通用操作：

索引/角标

>>> arr = ["a" , "b" , "c" , "d" , "e" , "f" , "g" , "h" , "i"]
>>> arr[0]
'a'
>>> arr[8]
'i'
>>> arr[-1] #倒数第一个
'i'
>>> arr[-9] #倒数第九个
'a'
>>>


#你试图访问的位置超出了列表实际内容的末尾
>>> 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
>>>

切片

new_list = even_numbers[1:4] 会创建一个新列表，包含原列表从索引1到3（不包括4）的元素

表达方式：

序列名[a : b : c]和循环中的range(a , b , c)类似

>>> arr[2:]#从下标为2的开始取到尾
['c', 'd', 'e', 'f', 'g', 'h', 'i']

>>> arr[1::2]#从下标为1的开始取，步长为2
['b', 'd', 'f', 'h']

>>> arr[:6]#从头取到下标为6的前一个（6下标不取）
['a', 'b', 'c', 'd', 'e', 'f']

>>> arr[:6:3]#从头取到下标为6的前一个，步长为3
['a', 'd']
>>> arr[:]

#从头取到尾
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
>>> arr[::]
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
>>> arr[::2]
['a', 'c', 'e', 'g', 'i']
>>>

<=======================================================================>

一类特殊的的切片方式，运用了Python的语法特性

>>> arr[-1:-7]#从尾取到头，步长必须是负数
[]
>>> arr[-1:-7:-1]
['i', 'h', 'g', 'f', 'e', 'd']


>>> arr[-9:7]#此时是从头取到尾，大意是从下标为0取到下标为7的前一个等价于arr[0,7]
['a', 'b', 'c', 'd', 'e', 'f', 'g']


>>> arr[-2:7]#因为倒数第二个的下标就是7，故不取
[]

>>> arr[::-1]#将列表反向输出，常运用于回文检查
['i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']
>>>

连接和重复+*

• 连接：s1 + s2（用于列表、元组或字符串）
• 重复：s * n

>>> arr[0] + arr[1]#进行拼接,注意技巧arr[1] + arr[0] >>>结果是'ba'
'ab'



>>> arr[0] = "我爱你"
>>> arr[0] * 5
'我爱你我爱你我爱你我爱你我爱你'
>>>

 成员资格

>>> 'a' in arr
True

>>> 'j' in arr
False
>>>

长度与最值 

>>> len(arr)
9
>>> max(arr)#ASCII码表的数值大小的比较
'i'
>>> min(arr)
'a'


>>> s = "ABCD"
>>> len(s)
4
>>> max(s)
'D'
>>> min(s)
'A'
>>>

1.12.2 列表

• 特点：列表是有序且可变的数据结构，可以包含任意类型和数量的元素，包括混合类型。列表用方括号 [ ] 包围元素，元素之间用逗号 , 分隔
• 操作：支持增、删、改、查操作，如 append、extend、insert、remove、pop、sort、reverse 等
• 索引和切片：可以使用索引访问单个元素或切片访问子序列

列表的创建

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)

列表对象函数

•  append()：在列表末尾添加元素

fruits = ['apple', 'banana']
fruits.append('orange')  # 添加一个元素
print(fruits)  # 输出：['apple', 'banana', 'orange']

• extend()：在列表末尾一次性添加多个元素（通常来自于另一个序列）

fruits = ['apple', 'banana']
more_fruits = ['orange', 'kiwi', 'pear']
fruits.extend(more_fruits)  # 扩展列表
print(fruits)  # 输出：['apple', 'banana', 'orange', 'kiwi', 'pear']

•  insert()：在列表的指定位置插入元素 

fruits = ['apple', 'banana', 'kiwi']
fruits.insert(1, 'strawberry')  # 在索引为1的位置插入一个元素
print(fruits)  # 输出：['apple', 'strawberry', 'banana', 'kiwi']

• remove()：移除列表中首次出现的指定元素

fruits = ['apple', 'banana', 'strawberry', 'banana']
fruits.remove('banana')  # 移除第一次出现的'banana'
print(fruits)  # 输出：['apple', 'strawberry', 'banana']

• pop()：移除并返回列表中指定索引处的元素，如果不指定索引，则默认移除并返回最后一个元素 

fruits = ['apple', 'banana', 'strawberry']
popped_fruit = fruits.pop()  # 移除并返回最后一个元素
print(popped_fruit)  # 输出：'strawberry'
print(fruits)  # 输出：['apple', 'banana']

• sort()：对列表内的元素进行排序（原地排序，改变原列表） 

fruits = ['banana', 'apple', 'orange', 'kiwi']
fruits.sort()  # 对列表进行升序排序
print(fruits)  # 输出：['apple', 'banana', 'kiwi', 'orange']


# arr.sort() # 默认升序
arr.sort(reverse = True) # 降序
arr = ["ABC", "123123123","我爱你中国","123123123","kasdkjas"]
arr.sort(key = len) # 以序列的长度为基准进行排序
print(arr)

• reverse()：反转列表中元素的顺序 

fruits = ['apple', 'banana', 'kiwi', 'orange']
fruits.reverse()  # 反转列表顺序
print(fruits)  # 输出：['orange', 'kiwi', 'banana', 'apple']

• count(): 

# 统计列表当中 某一个元素出现的次数
arr = [1,2,3,4,1,2,3,1,1,2,0,0,1]
print(arr.count(1))

• 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 找不到则报错
"""

• clear(): 

arr = [1,2,3,4]
arr.clear()
print(arr)

•  copy():

copy()函数只对第一层地址进行拷贝,若序列中还有序列,那么深层次的地址不拷贝

这样会造成指向对象的不同

# 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关键字 

# 额外的知识
# 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)
"""

1.12.3字符串

• 特点：字符串是由一系列字符组成的不可变序列，可以包含文本信息。字符串可以用单引号 ' 或双引号 " 创建，也可以用三引号 ''' 或 """ 创建多行字符串。
• 操作：由于字符串是不可变的，所以不能改变字符串本身的值，但可以利用字符串的相关方法生成新的字符串，如 join、split、replace、find、lower、upper 等。
• 索引和切片：同样支持索引访问单个字符和切片获取子字符串。

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

greeting = "Hello, World!"  # 一个简单的问候语字符串


multiline_text = """这是一个
多行
字符串实例"""

>>> 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

• is---系列

# 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():

join() 将字符串列表进行拼接的
arr = ["banana", "orange", "apple","pich"]
s = "-".join(arr)
print(s)

• ljust()左对齐         rjust():右对齐 

# ljust()左对齐 rjust()右对齐
print("ABC".ljust(10, "#"))
print("ABC".rjust(10, "#"))

• lower():大写字母转小写        upper():小写字母转大写 

print("Hello World123".lower())

• lstrip():去除左边的空格        rstrip():去除右边的空格        strip():两边都去掉空格 

# 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() :

# split() 以某一个分割符来切割字符串 结果是一个字符串的列表
s = "泰罗-杰克-赛文-迪迦-梦比优斯"
arr = s.split("-")
print(arr)
arr = "1 2 34 4.12".split(" ")
print(arr)

1.12.4元组

• 特点：元组也是有序的，但是它的元素是不可变的，即创建后不能更改其内容。元组用圆括号 ( ) 包裹元素，同样支持混合类型。
• 操作：尽管不能修改元组内容，但可以对元组进行连接、重复等操作，同时因为其不可变性，元组在作为函数参数传递时效率更高，也常用于创建不变的数据结构。

coordinates = (40.7128, -74.0060)  # 一个表示纽约市经纬度的元组

1.12.5集合

• 特点：集合是一个无序且唯一性的数据结构，不允许重复元素存在。集合用大括号 { } 包含元素，元素间不需分隔符，因为集合内部自动去重。
• 操作：集合主要用来做成员测试、交集、并集、差集等数学集合操作，比如 add、update、remove、discard、union、intersection、difference 等。

unique_colors = {'red', 'green', 'blue', 'yellow'}  # 一个包含不同颜色的集合，自动去除重复项

1.12.6字典

• 特点：字典是一种无序的键值对(key-value pairs)数据结构，键必须是唯一的且不可变类型（如字符串、数字或元组），值则可以是任意类型。字典用花括号 { } 包含键值对，键值之间用冒号 : 分隔，各个键值对之间用逗号 , 分隔。
• 操作：字典通过键来查找、增加、删除或更新对应的值，提供 get、setdefault、update、pop、keys、values、items 等方法。

 # 一个人的信息字典，键值对表示姓名、年龄和城市
person_info = {'name': 'Alice', 'age': 30, 'city': 'New York'} 

1.12.7 math模块

#导入模块
import math

1. **常量**：
   - `math.pi`: 圆周率（π），约等于 3.141592653589793。
   - `math.e`: 自然对数的底数（e），约等于 2.718281828459045。
   - `math.tau`: 圆周常数（τ），等于 2π，约等于 6.283185307179586。
   - `math.inf`: 正无穷大。
   - `math.nan`: 特殊浮点数，表示“非数字”（Not a Number）。

2. **三角函数**：
   - `math.sin(x)`: 计算正弦。
   - `math.cos(x)`: 计算余弦。
   - `math.tan(x)`: 计算正切。
   - `math.asin(x)`: 计算反正弦（逆正弦）。
   - `math.acos(x)`: 计算反余弦（逆余弦）。
   - `math.atan(x)`: 计算反正切（逆正切）。
   - `math.atan2(y, x)`: 计算角度（从-π到π），其正切值为 `y / x`，考虑了 `x` 和 `y` 的符号以确定正确的象限。

3. **双曲函数**：
   - `math.sinh(x)`: 计算双曲正弦。
   - `math.cosh(x)`: 计算双曲余弦。
   - `math.tanh(x)`: 计算双曲正切。
   - `math.asinh(x)`: 计算反双曲正弦（逆双曲正弦）。
   - `math.acosh(x)`: 计算反双曲余弦（逆双曲余弦）。
   - `math.atanh(x)`: 计算反双曲正切（逆双曲正切）。

4. **指数与对数**：
   - `math.exp(x)`: 计算以自然对数 `e` 为底的指数函数。
   - `math.expm1(x)`: 计算 `exp(x) - 1`，提供更高的精度，特别是在 `x` 接近零时。
   - `math.log(x[, base])`: 计算自然对数（默认基为 `e`），可选参数 `base` 指定其他基数。
   - `math.log10(x)`: 计算以10为底的对数。
   - `math.log2(x)`: 计算以2为底的对数。
   - `math.log1p(x)`: 计算 `log(1 + x)`，提供更高的精度，特别是在 `x` 接近零时。

5. **功率与根**：
   - `math.pow(x, y)`: 计算 `x` 的 `y` 次幂。
   - `math.sqrt(x)`: 计算 `x` 的平方根。

6. **浮点数特性与操作**：
   - `math.ceil(x)`: 向上取整，返回大于或等于 `x` 的最小整数。
   - `math.floor(x)`: 向下取整，返回小于或等于 `x` 的最大整数。
   - `math.trunc(x)`: 舍去小数部分，返回 `x` 的整数部分。
   - `math.copysign(x, y)`: 返回 `x` 的绝对值与 `y` 的符号相结合的值。
   - `math.fabs(x)`: 计算 `x` 的绝对值。
   - `math.fmod(x, y)`: 计算 `x` 除以 `y` 的余数，遵循C语言中的定义。
   - `math.remainder(x, y)`: 计算 `x` 除以 `y` 的余数，遵循IEEE 754规范。
   - `math.frexp(x)`: 将 `x` 分解为分数部分（返回值）和指数部分（第二个返回值），满足 `x = m * 2**e`，其中 `0.5 <= abs(m) < 1`。
   - `math.ldexp(x, i)`: 计算 `x * 2**i`。
   - `math.modf(x)`: 将 `x` 分解为整数部分（返回值）和小数部分（第二个返回值）。

7. **特殊函数与常微分方程求解器**：
   - `math.erf(x)`: 计算误差函数。
   - `math.erfc(x)`: 计算互补误差函数（1 - erf(x)）。
   - `math.gamma(x)`: 计算伽马函数。
   - `math.lgamma(x)`: 计算伽马函数的自然对数。

8. **度与弧度转换**：
   - `math.radians(x)`: 将角度转换为弧度。
   - `math.degrees(x)`: 将弧度转换为角度。

9. **数值比较与处理**：
   - `math.isclose(a, b[, rel_tol, abs_tol])`: 判断两个浮点数 `a` 和 `b` 是否足够接近。
   - `math.isfinite(x)`: 判断 `x` 是否为有限数值（非无穷大、非NaN）。
   - `math.isinf(x)`: 判断 `x` 是否为正无穷大或负无穷大。
   - `math.isnan(x)`: 判断 `x` 是否为非数字（NaN）。

10. **其他数学操作**：
    - `math.factorial(n)`: 计算整数 `n` 的阶乘。
    - `math.gcd(a, b)`: 计算整数 `a` 和 `b` 的最大公约数。
    - `math.hypot(x, y)`: 计算直角三角形斜边长，对应于 `x` 和 `y` 分别为两条直角边的长度。
    - `math.fsum(iterable)`: 计算可迭代对象中浮点数的精确和，减少浮点加法误差累积。

1.12.8 random模块

#导入模块
import random

1. **基本随机数生成**:
   - `random.random()`: 生成一个位于区间 [0.0, 1.0) 内（含0.0，不含1.0）的随机浮点数。
   - `random.uniform(a, b)`: 生成一个位于指定区间 [a, b] 内（含a和b）的随机浮点数。

2. **整数随机数生成**:
   - `random.randint(a, b)`: 生成一个位于区间 [a, b] 内（含a和b）的随机整数。
   - `random.randrange([start], stop[, step])`: 生成一个位于区间 `[start, stop)` 内（含 `start`，不含 `stop`）的随机整数，可选参数 `step` 指定步长。

3. **序列操作**:
   - `random.choice(sequence)`: 从给定的序列（如列表、元组或字符串）中随机选择并返回一个元素。
   - `random.choices(population, weights=None, k=1)`: 从给定的 `population` 中按可选权重 `weights` 随机选择并返回 `k` 个元素的列表。
   - `random.sample(sequence, k)`: 从给定的序列中无放回地随机选择并返回一个包含 `k` 个元素的子序列（列表）。
   - `random.shuffle(x[, random])`: 将列表 `x` 中的元素随机重新排列（就地操作，即直接修改原列表）。

4. **随机数生成器控制**:
   - `random.seed(a=None, version=2)`: 设置随机数生成器的种子。如果不提供参数，则使用当前时间作为种子。`version` 参数指定随机数生成器的版本。

5. **其他功能**:
   - `random.getstate()`: 获取当前随机数生成器的状态，可用于保存状态并在后续恢复。
   - `random.setstate(state)`: 从先前保存的状态 `state` 恢复随机数生成器。
   - `random.jumpahead(n)`: 快速推进随机数生成器的状态，跳过 `n` 个内部步骤。