Python学习笔记：基础阶段

一、软件概述

1.1软件的定义

软件是指一些按照特定顺序组织的能够被计算机识别的数据与指令的集合。

1.2软件的分类

操作系统软件：Windows、Android、IOS、Harmony

负责管理和调控计算机硬件，给用户提供最基本的计算机功能（磁盘管理、上网管理、内存管理、用户管理等）。

应用软件：微信、支付宝、抖音、网易云

负责提供专业领域服务的软件，基于操作系统软件运行。

1.3编程语言

机器语言：所有的数据都是由0和1组成，人类看不懂，给机器看的。

汇编语言：add，必须考虑计算机的执行过程，门槛高。

高级语言：C、C++、Java、Python、JavaScript等，以人类的角度设计，对学习者非常友好，但是计算机看不懂。

1.4进阶知识

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

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

1.编译与解释的区别：

编译：相当于用中英文词典（翻译器）将一本英文书一次性翻译（编译）成一本中文书。以后查看直接就是中文了。

解释：相当于用中英文词典（翻译器）将一本英文书读一段翻译一段（解释）中文。以后查看时还是需要重新翻译。这样效率会低一些，必须依赖解释器，但是跨平台性好。

2.静态与动态的区别：

静态语言：静态对于变量有明确的类型定义。

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

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

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

动态语言：动态对变量没有明确的类型定义，所有的数据都是对象，所有的变量都是引用数据类型变量。

二、安装环境

2.1Python开发工具包

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

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

如果没有出现以上提示，去找到Python的安装目录： C:\Users\Administrator\AppData\Local\Programs\Python\Python312

我的电脑图标，邮件，属性，高级系统设置，环境变量，Path，双击，新建，粘贴路径，确定，确定， 确定，重新打开CMD窗口测试

2.2VSCode

https://code.visualstudio.com/

熟悉使用英文版

三、脚本与交互

3.1交互模式：

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

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

一般在简单的代码演示、测试才会使用到交互模式，为了永久保存代码，需要用到脚本模式。

3.2脚本模式：

打开VSCode、点击File，New Folder选择代码目录（可以在桌面创建一个专门放python代码文件的文件夹，再到VSCode里面选择该文件夹），再点击New File按钮创建文件，输入名称和后缀名（.py）。                       

ps：写代码时要养成随时按crtl + s 的习惯保存代码

接着就是运行Python脚本文件，可以通过下面两种方法：

（1）打开CMD窗口，进入到代码目录路径（cd 目标目录），再输入指令：python xxx.py 来运行目标python文件。

（2）在VSCode里面打开终端运行，具体操作：点击上方导航栏的Terminal，再点击New Terminal就可以之间进入到终端窗口，再输入指令：python xxx.py 来运行目标python文件。

四、基本数据

4.1常量

不能够改变的量-字面量

（1）整数常量：

>>> print(10)    #十进制
10
>>> print(0b1001)    #二进制 binary
9
>>> print(0o12)    #八进制 octal
10
>>> print(0x12)    #十六进制 hexadecimal
18

ps：没有byte、short、long之分，一律默认int。

（2）小数常量：

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

ps:没有float与double之分，默认float。

（3）字符串常量：

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

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

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

（4）布尔值常量：

只有两个值True（1），False（0）。

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

ps：True和False在编写代码中，T和F要大写。

4.2标识符

由程序员自定义的一些名称（变量、函数、类）

规则：

（1）由字母、数字、下划线、美元符组成。

（2）数字不能开头。

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

规范：

（1）小驼峰：变量、函数。多个单词出现时，第一个单词首字母小写，之后单词首字母都大写。

例如：userName。

（2）大驼峰：类。所有单词首字母大写。

例如：UserName。

（3）下划线分割：单词之间用下划线分割，不大写。

例如：user_name

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

4.3关键字

一些单词被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']

4.4内置函数名/类名

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

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

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

4.5注释

单行注释：

# 注释的内容

多行注释：

"""
注释的内容
"""

4.6变量

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

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

# 变量 = 数据
# 单独定义一个变量时
>>> 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

ps：在C、Java中，变量使用格式为： 数据类型 变量名 = 数据 ；

五、数据转换

5.1数据类型转换

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

>>>int(3.14)    #将小数进行取整操作
3.14

>>>int("123")    #将数字字符串进行解析，默认十进制，解析出整数
123

>>>int("AD" , 16)    #将数字字符串进行十六进制解析，转换为十进制
173

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

>>> float(3)
3.0

>>> float("3.14")
3.14

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

>>> str(123)
'123'

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

>>> bool(1)
True

>>> bool(0)
False

ps：对于数值类型的话，非0全是True，0就是False

5.2进制转换

>>> bin(123) # 转二进制字符串
'0b1111011'

>>> oct(123) # 转八进制字符串
'0o173'

>>> hex(123) # 转十六进制字符串
'0x7b'

5.3字符与ASCII码转换

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

>>> ord('a')
97

>>> ord('A')
65

>>> ord('0')
48

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

>>> chr(98)
'b'

>>> chr(57)
'9'

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

5.4常见的数学计算

>>> abs(3.14) # 取绝对值
3.14

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

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

>>> round(3.14) #四舍五入
3

六、输入与输出

input()：

num = eval(input("请输入一个数字:")) 

# input()默认输入的是一个字符串(整行)，如需转换可以用int()，或者eval()
# 处理一行内多个数据的输入
# eval处理的数据必须要有逗号分隔
# eval自动处理字符串解析
# eval既可以处理单值 也可以处理多值

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() # 单独一个print换行的意思 其实打印的是空串

# 格式化输出
name = "旺财"
age = 18
height = 1.23
print("它叫", name, "，今年", age, "岁", sep = "")
# %s 对应字符串 %d 对应整数 %f 对应小数
print("它叫%s，今年%d岁，身高%.2f米" % (name, age, height))

七、运算符

7.1算数运算符

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

减法：数值相减

>>> 1 + 2
3

>>> "123" + "456"
'123456'

>>> 2 - 1
1

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

>>> 3 * 6
18

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

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

>>> 10 / 3
3.3333333333333335

>>> 10 // 3
3

幂运算：**

>>> 2 ** 3
8

取余：%

>>> 10 % 3
1

7.2布尔判断运算符

> （大于）、<（小于）、>=（大于等于）、<=（小于等于）、!=（不等于）、==（等于）

运算结果一律为布尔值

扩展：
在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 == b 比的是对象的内容 但是a和b存的地址一样

7.3增强型赋值运算符

+=、-=、*=、/=、//=、**=、%=

a += 2    # a = a + 2

b **= 2    # b = b ** 2

7.4逻辑运算符

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

与：全真则真 有假则假

或：有真则真 全假则假

非：取反

>>> 1 < 2 and 2 < 3
True

>>> 1 < 2 or 2 > 3
True

>>> not 1 < 2
False

7.5位运算符

&按位与

>>> 13 & 7
5

"""
1101
0111
0101 = 5
"""

|按位或

>>> 13 | 7
15

"""
1101
0111
1111 = 15
"""

>> 右移

>>> 16 >> 2
4

"""
10000
  100|00
  100 = 4
"""

<< 左移

>>> 2 << 3
16

"""
0010
0010000
10000 = 16
"""

~取反 符号取反再减1

>>> ~15
-16

"""
01111 = 15
10000 = -16
"""

^ 异或：相等为假 不同为真

>>> 13 ^ 7
10

"""
1101
0111
1010 = 10
"""

7.6成员运算符

in 和 not in

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

>>> "abc" in "sakjdgjhsgadugashjdvasvdjgsa"
False

>>> "abc" in "sakjdgabca"
True

>>> 1 in [2,3,4]
False

7.7从属/身份运算符

is 和 not is

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

>>> a = 1
>>> b = 1
>>> a is b
True

>>> a = 1000
>>> b = 1000
>>> a is b
False

这里前面提过，-5~256范围内，Python会自动创建这些数据对象，提供给调用者使用，超过这个范围则会创建新的对象。

八、条件判断

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

单if语句

if 条件语句:

        条件为真时执行的内容

if-else语句

if 条件语句:

        条件为真时执行的内容

else:

        条件为假时执行的内容

if-elif语句 else 

if 条件语句1:

        条件语句1为真时执行的内容

elif 条件语句2:

        条件语句2为真时执行的内容

else:

        所有条件都不满足时执行的内容

语句嵌套

if 条件1:

        if 条件2:

                执行内容(1和2都满足)

        else:

                执行内容(满足1不满足2)

else:

        执行内容(1和2都不满足)

九、循环语句

循环四要素：

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

for i in range(1，101):    #打印1~100的整数
    print(i)


for i in "abcdefg":    #遍历字符串中的字符并打印
    print(i)

十、列表与字符串

10.1序列通用操作

索引/角标

>>> arr = [1,2,3,4,5,6,7,8,9]
>>> arr[0]    #下标从0开始
1
>>> arr[-1]    #倒数第1个
9

切片：就是获取序列中某一个连续子区间

序列名[a：b：c]和range(a，b，c)基本类似

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

成员资格

>>> 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
>>> max(arr)    #获取序列的最大值
9
>>> min(arr)    #获取序列的最小值
1

10.2常见操作

创建问题

列表：

• 存储多个数据，数据不一定都是同一个类型，但是为了方便操作，建议存一样的类型
• 可以通过索引/角标来访问元素
• 可变长的数组，方便后续可以对列表进行增、删、改。
• 用一对中括号

#创建一个空的列表
arr = []

#创建一个具有若干元素的列表
arr = [1, 2, 3, 4]

#通过【列表推导式/解析式】来进行创建
#例如：创建1~100的偶数
arr = [x for x in range(1, 101) if x % 2 == 0]

#通过输入来获取元素
arr = input().split(" ")    #将输入的数据以空格分割，分割的结果就是列表
arr = [int(x) for x in arr]    #输入的数据为字符，这里通过int()将其转换为整数

遍历问题

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)

最值问题

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]

#通过切片完成翻转
arr = arr[-1::-1]
print(arr)

#通过for循环完成翻转
for i in range(0, len(arr) // 2):    
    j = len(arr) - 1 - i
    arr[i], arr[j] = arr[j], arr[i]
print(arr)

#通过while循环语句完成翻转
left = 0
right = len(arr) - 1
while left <= right:
    arr[left], arr[right] = arr[right], arr[left]
    left += 1
    right -= 1
print(arr)

10.3排序算法

选择排序：从第一个数开始与后面的每一个数进行比较，每一轮走完求出的为最小值

arr = [6, 2, 1, 4, 5, 8, 9, 7, 3]
for i in range(len(arr) - 1):    #最后一个数不用比较
    for j in range(i + 1, len(arr)):    #j为被比较的数，所以是i + 1
        if arr[i] > arr[j]:        #当前一个数大时，与后一位数交换位置，留在前面的为最小值
            arr[i], arr[j] = arr[j], arr[i]
print(arr)

冒泡排序：比较两个数，数值大的往后交换，每一轮走完求出的为最大值，下一轮比较的次数则少一轮

arr = [6, 2, 1, 7, 4, 3, 9, 8, 5]
for i in range(1, len(arr)):        #最后一个数不用比
    for j in range(len(arr) - i):        #每轮比较完求出最大值，则下一轮比较的次数-i
        if arr[j] > arr[j + 1]:        #每次比较出的较大值往后移，每轮比完求出最大值
            arr[j], arr[j + 1] = arr[j + 1], arr[j]
print(arr)

插入排序：比较两个数，从第二个数开始，每轮与前一个数进行比较，直到左边没数或者比左边数要大则结束该轮，每轮比较求出较小值放前面，且前面的数都为有序排列

for i in range(1,len(arr)):    #从第二个数开始进行每一轮比较
    e = arr[i]        #将比较的数赋给e，方便后续直接插入到对应位置
    j = i        #将比较的数的下标赋给j，方便后续的条件判断
    while j >= 1 and e < arr[j - 1]:        #判断数值左边是否有数，且左边的数小于该数值时执行
        arr[j] = arr[j - 1]        #将左右两边交换位置
        j = j - 1        #j值- 1，判断交换位置后的位置，再进行条件判断
    arr[j] = e        #最后条件判断结束，将之前存储i的值放到对应的位置
print(arr)

计数排序：统计一组列表当中数字出现的次数，再从小到大依次排序输出

arr1 = [8,2,1,4,8,7,9,2,3,4,3,5,6,3]
minValue = min(arr1)
maxValue = max(arr1)      #列表里的最大最小值
arr2 = [0] * (maxValue - minValue + 1)      #用来计数的列表，长度为最小值到最大值
for i in range(len(arr1)):        #从角标0开始，遍历整个列表
    arr2[arr1[i] - minValue] += 1       #将列表1内每个数字出现的次数计入到列表2当中

k = 0        #k值对应的是录回列表1的角标
for j in range(len(arr2)):
    while arr2[j] > 0:      #每当计数列表（列表2）中的值大于0，就将其值替换到arr1当中，实现从小到大依次排序
        arr1[k] = j + minValue        #从最小值开始，依次加对应角标，得到的就是对应的数字
        k += 1        #录回一个数值，则下标+1，继续录入下一个数值
        arr2[j] -= 1        #每次录入一个数时，在列表2中出现的次数就-1，直到0，就是将该数全部录入进去结束循环
print(arr1)

10.4查找算法

二分查找：要求数据必须有序，通过最小最大值来求出中间值，直到找到需要的数值

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:    #如果查找的数不在列表中，则返回-1
        midIndex = -1
        break
    midIndex = (minIndex + maxIndex) // 2
print(midIndex)

插值查找：要求数据必须有序，通过元素的分布情况来查找元素，适用于元素均匀分布的情况

arr = [1,12,24,31,32,36,45,54,58,62,68,74,86,95,100]
low = 0        #区间最小值角标
high = len(arr) - 1        #区间最大值角标
mid = 0        #区间中间值角标，先定义
key = eval(input())        #用户输入需要查找的值
while True:        #循环语句，达到对应条件时跳出循环，或者为Flase
    
    #中间值 = （查找值 - 最小值） / (最大值 - 最小值） * （最大值角标 - 最小值角标） + 最小值角标
    #其中 “（查找值 - 最小值） / (最大值 - 最小值）” 为百分数，再乘对应区间内的角标加上最小角标，判断出数值的大概位置，所以前面要用到int将小数转换为整数
    mid = int((key - arr[low]) / (arr[high] - arr[low]) * (high - low) ) + low

    if mid > high or mid < low:        #如果一直循环，则中间值会小于或大于最大值，这种情况则是寻找值不在该列表中，所以返回一个 -1 并跳出死循环
        mid = -1
        break
    elif key == arr[mid]:        #查找到该值时，其下标则对应mid值，直接跳出循环
        break
    elif key > arr[mid]:        #当查找的值大于大概的中间值，则最小区间值从中间值后一位开始，重新判断区间
        low = mid + 1
    elif key < arr[mid]:        #当查找的值小于大概的中间值，则最大于区间值从中间值前一位开始，重新判断区间
        high = mid - 1
    
print(mid)        #最后输出的值则为查找值的对应下标，或者 -1

10.5列表对象函数

对象函数是区别于内置函数的，内置函数直接调用即可len() 、max() ，对象函数必须通过某一个具体的对象来调用。如：列表.函数名()、

append()：将某一个元素对象添加在列表的表尾，如果添加的时其他的序列，该序列也会被看成是一个数据对象

>>> arr = [1,2,3,4]
>>> arr.append(5)
>>> print(arr)
[1, 2, 3, 4, 5]

>>> arr2 = [6,7,8]
>>> arr.append(arr2)
>>> print(arr)
[1, 2, 3, 4, 5, [6, 7, 8]]

count()：统计列表当中，某一个元素出现的次数

>>> arr = [1,2,4,5,6,3,3,1,4,5,2,3,5]
>>> print(arr.count(1))
2
>>> print(arr.count(3))
3

extend()：在当前列表中，将传入的其他序列的元素添加在表尾

>>> arr1 = [1,2,3]
>>> arr2 = [4,5,6]
>>> arr1.extend(arr2)
>>> print(arr1)
[1, 2, 3, 4, 5, 6]
>>> arr1.extend("ABC")
>>> print(arr1)
[1, 2, 3, 4, 5, 6, 'A', 'B', 'C']

ps：只能添加序列，如果添加整数，则会报错，如下图：

index()：从左至右查找元素第一次出现的位置（角标）

>>> arr = [1,2,3,4,5,6,7,4,5,6,9]
>>> print(arr.index(4))
3
>>> print(arr.index(4, 5, 8))        #在[5, 8)区间内找 4 的角标
7

insert(index, obj)：在某一个角标处插入一个元素

>>> arr = [1,2,3,4]
>>> arr.insert(2, 5)
>>> print(arr)
[1, 2, 5, 3, 4]

pop()：弹栈。删除最后一个元素并返回其值，也可以用来删除指定角标处的元素（一般不使用）

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

remove()：移除指定元素（从左至右第一次出现的）

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

reverse()：翻转列表

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

sort()：排序。默认升序，如需要降序，则输入参数reverse = True

>>> arr = [4,5,7,9,8,1,3,2,6]
>>> arr.sort()    #默认升序
>>> print(arr)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> arr.sort(reverse = True)    #降序
>>> print(arr)
[9, 8, 7, 6, 5, 4, 3, 2, 1]

#扩展
>>> arr = ["ABC", "123123123","我爱你中国","123123123","kasdkjas"]
>>> arr.sort(key = len)
>>> print(arr)
['ABC', '我爱你中国', 'kasdkjas', '123123123', '123123123']

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

>>> arr1[0] = 5
>>> print(arr2[0])
1
#上述代码在arr1中修改元素 并不影响arr2

>>> arr1 = [1,2,3,[4,5,6]]
>>> arr2 = arr1.copy()
>>> arr2[3][0] = 666
>>> print(arr1[3])
[666, 5, 6]
#上述代码在arr2中修改元素 影响arr1

扩展知识：

del关键字：删除

>>> arr = [1,2,3,4]
>>> del arr[0]
>>> print(arr)
[2, 3, 4]

>>> del arr    #删除arr列表，则下面打印arr会报错
>>> print(arr)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'arr' is not defined. Did you mean: 'arr2'?

10.6字符串对象函数

可变对象

可变对象可以在创建后修改其内容。常见的可变对象类型有：列表、字典、集合

列表是一个典型的可变对象。你可以添加、删除或修改列表中的元素，而不需要创建新的列表对象。

不可变对象

不可变对象一旦创建，其内容就不能被修改。如果尝试修改一个不可变对象，实际上会创建一个新的对象，而不是改变原来的对象。常见的不可变对象类型有：数字、字符串、元组

字符串就是一个不可变对象。当你对一个字符串进行修改时，会创建一个新的字符串对象，而不是改变原来的字符串。

>>> arr = [1,2,3]
>>> arr[0] = 4
>>> print(arr)
[4, 2, 3]
#列表对象支持元素修改

>>> s = "ABC"
>>> print(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)
ABC
>>> print(s2)
###ABC####

count()：和列表的count相似，统计字符串的个数

>>> s = "abchjghjabcjkhjkhabchkjhabc"
>>> print(s.count("abc"))
4
>>> print(s.count("a"))
4

>>> s = "AAAAAAAA"
>>> print(s.count("AAA"))
2
#count是非贪心统计，贪心统计6个

endswith()：过滤字符串结尾，也可以指定区间

>>> s = "名侦探柯南.jpg"
>>> print(s.endswith(".jpg"))
True

find()：寻找字符串第一次出现的位置，也可以指定区间

>>> s = "八百标兵奔北坡"
>>> print(s.find("标兵"))    #指定的是“标”的角标
2
>>> print(s.find("A"))
-1
#如果找不到，则返回-1

format()：格式化输出

>>> name = "小强"
>>> age = 18
>>> print("我的名字叫{}, 年龄{}岁".format(name, age))
我的名字叫小强, 年龄18岁
>>> print(f"我的名字叫{name}, 年龄{age}岁")
我的名字叫小强, 年龄18岁

index()：寻找字符串第一次出现的位置，也可以指定区间

>>> s = "八百标兵奔北坡"
>>> print(s.index("标兵"))
2
>>> print(s.index("A"))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
#如果找不到，则报错

isalnum()：判断字符串是否是字母或数字

>>> print("abc".isalnum())
True
>>> print("123".isalnum())
True
>>> print("abc123".isalnum())
True
>>> print("abc123^&%&^&".isalnum())
False

扩展：

isalpha() 是否是纯字母字符串

isdecimal() 是否是十进制纯数字字符串

isdigit() 是否是纯数字字符串

isspace() 是否是纯空格字符串

islower() 出现的字母是否是小写字母

isupper() 出现的字母是否是大写字母

join()：将字符串列表进行拼接的

>>> arr = ["banana", "orange", "apple","pich"]
>>> s = "-".join(arr)
>>> print(s)
banana-orange-apple-pich

ljust()：左对齐

rjust()：右对齐

>>> print("ABC".ljust(10, "#"))
ABC#######
>>> print("ABC".rjust(10, "#"))
#######ABC

lower()：出现的大写字母转小写

upper()：出现的小写字母转大写

>>> print("Hello World123".lower())
hello world123
>>> print("Hello World123".upper())
HELLO WORLD123

lstrip()：去除左边空格

rstrip()：去除右边空格

strip()：去除左右边空格

>>> print(" ABC ".lstrip())
ABC
>>> print(" ABC ".rstrip())
 ABC
>>> print(" ABC ".strip())
ABC

replace(a,b)：替换。a旧、b新

>>> s = "宇智波佐助、宇智波斑、宇智波鼬、宇智波泉奈、宇智波止水、宇智波卡卡西"
>>> s1 = s.replace("宇智波","千手")
>>> print(s)
宇智波佐助、宇智波斑、宇智波鼬、宇智波泉奈、宇智波止水、宇智波卡卡西
>>> print(s1)
千手佐助、千手斑、千手鼬、千手泉奈、千手止水、千手卡卡西

split()：以某一个分割符来切割字符串 结果是一个字符串的列表

>>> s = "泰罗-杰克-赛文-迪迦-梦比优斯"
>>> arr = s.split("-")
>>> print(arr)
['泰罗', '杰克', '赛文', '迪迦', '梦比优斯']

math模块

math模块在 Python 中提供了许多数学函数和常量，用于执行常见的数学运算和转换。这个模块通常用于浮点数运算，并且大部分函数只接受浮点数作为参数。

要使用math模块中的函数和常量，你需要先导入该模块：import math

常量：

• math.pi：表示圆周率 π 的值
• math.e：表示自然对数的底数 e 的值
• math.inf：表示正无穷大
• math.nan：表示非数字（Not a Number）

三角函数：

• math.sin(x)：返回 x（以弧度为单位）的正弦值
• math.cos(x)：返回 x（以弧度为单位）的余弦值
• math.tan(x)：返回 x（以弧度为单位）的正切值

幂和对数函数：

• math.pow(x,y)：返回x的y次方
• math.sqrt(x)：返回x的平方根
• math.exp(x)：返回e的x次方
• math.log(x, [base])：返回以base为底x的对数
• math.log10(x)：返回x的以10为底的对数
• math.log2()：返回x的以2为底的对数

其他常用函数：

• math.ceil(x)：返回大于或等于x的最小整数
• math.floor(x)：返回小于或等于x的最小整数
• math.fabs(x)：返回x的绝对值
• math.factorial(x)：返回x的阶乘
• math.fmod(x,y)：返回x除以y的余数
• math.gcd(x,y)：返回x和y的最大公约数

random模块

random模块在 Python 中提供了生成随机数的功能。这个模块包含了许多用于生成不同类型随机数的函数，从简单的随机整数和浮点数到从序列中随机选择元素等。

要使用random模块中的函数和常量，你需要先导入该模块：import random

随机数生成：

• random.random()：返回一个[0.0, 1.0) 之间的随机浮点数
• random.uniform(a, b)：返回一个 [a, b) 之间的随机浮点数
• random,randint(a,b)：返回一个 [a, b]之间的随机整数，包括 a和 b
• random,randrange(a,b)：返回一个 [a, b)之间的随机整数，不包括 b

序列随机选择：

• random,choice(seq)：从非空序列 seq 中随机选择一个元素
• random,shuffle(seq)：就地打乱序列 seq 的元素
• random,sample(population,k)：从 population 序列中随机选择 k个不重复的元素，返回一个列表

其他函数：

• random.getrandbits(k)：返回一个带有k个随机比特的整数
• random.getstate()：返回表示当前随机数生成器状态的对象
• random,setstate(state)：设置随机数生成器的状态

十一、函数/方法

主要解决的问题：将那些具有独立性功能的，且重复的代码进行封装

Python当中 函数的语法格式：

def 函数名(参数列表):
    函数体，具体的执行内容
    return 返回值

# 如果函数不需要返回 则可以不写return
# return 它仅仅表示结束当前函数 如果有返回值则写上 没返回值可以不写return 默认返回None
# 函数必须先定义 再调用（除了面向对象在类中定义函数时）