Python笔记

一、Python是一种高级语言

python源代码转换为在Windows上可执行的程序的过程与C语言、java语言的区别：

二、安装环境

Python开发工具包

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

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

VSCode

https://code.visualstudio.com/

三、脚本与交互

交互模式：

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

print() 输出函数，输出的内容写在一对小括号中 print(XXX)

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

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

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

脚本模式：

打开 VSCode ， File ， New Folder ，选择代码目录， New File 按钮创建文件，输入名称和后缀名 (.py)     （注意：一定要养成随时按crtl+s的习惯 保存）

如何运行 Python 脚本文件呢：

四、基本数据

1、 常量：不能够改变的量     

整数常量：10（十进制）、0b1001(二进制)、0o12（八进制）、0x12（十六进制） （注意：没有byte short long 之分 一律默认int）

小数常量：1.34  （注意：没有float与double之分 默认float）

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

 

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

1+2+3

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

1+2+3

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

布尔值常量：只有两个值 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)

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

  规则：1、由字母、数字、下划线、美元符组成

             2、数字不能开头

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

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

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

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

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

关键字：就是一些单词，被 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 自带的一些具有特殊功能的函数

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

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

注释：

单行注释：

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

多行注释：

"""

中间多行注释

"""

变量：

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

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

五、数据转换

>>> int a = (int) 3.14

3

>>> int("123")

123

int() 将其他有效的数据转为整数或者 从字符串中解析整数

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

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

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

# 对于数值类型的话 非 0 全是 True 0 就是 False

>>> bool(1)

True

>>> bool(-1)

True

>>> bool(0)

False

>>> bool(3.14)

True

>>> bool(-3.14)

True

# 对字符串 空串为 False 非空为 True

>>> bool("abc")

True

>>> bool("") # 空串

False

进制转换： （参数必须是整数）

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

'0b1111011'

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

'0o173'

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

'0x7b'

字符与 ASCII 码转换：

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

>>> ord('a')

97

>>> ord('A')

65

>>> ord('0')

48

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

>>> chr(98)

'b'

>>> chr(57)

'9'

常见的数学计算：

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

3.14

>>> abs(-3.14)

3.14

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

16

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

4

>>> min(1,2,3,4)

1

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

3

六、输入与输出

input()  

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

# input() 默认输入的是一个字符串 ( 整行 )

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)

七、运算符

算数运算符：

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

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

幂运算：

>>> 2 ** 3

8

>>> 16 ** 0.5

4.0

取余：

>>> 10 % 3

1

布尔判断运算符：运算结果一律为布尔值

>  、 < 、  >=  、 <= 、  != 、  ==

Python 允许连续比较

>>> 1 < 2 < 3

True

>>> 1 < 2 and 2 < 3

True

增强型赋值运算符：

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

a += 2

a = a + 2

b **= 2

b = b ** 2

逻辑运算符：

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

与：全真则真 有假则假

或：有真则真 全假则假

非：取反

>>> 1 < 2 and 2 < 3

True

>>> 1 < 2 or 2 > 3

True

>>> not 1 < 2

False

位运算符：

& 按位与

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

成员运算符：

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

八、条件判断

只有 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都不满足)

九、循环语句

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

向前走 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++;
}
Python中
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 = [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)

插值查找：数据必须是有序的，除了要考虑位置还得考虑元素的分布情况

"""
插值查找适用于数据分布比较均匀的情况
low 区间最小值角标
high 区间最大值角标
mid 区间中间值角标
mid = (key- arr[low]) / (arr[high] - arr[low]) * (high - low) + low
"""
arr = [1,12,24,31,32,36,42,45,51,52,65,72,99]
low = 0
high = len(arr) - 1
mid = 0
key = 31
while True:
    mid = int((key - arr[low]) / (arr[high] - arr[low]) * (high - low)) + low
    if mid > high or mid < low:
        mid = -1
        break
    if arr[mid] == key:
        break
    elif arr[mid] < key:
        low = mid + 1
    else:
        high = 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)

math模块

math模块提供了许多数学函数和常量，可以用于进行各种数学运算和常数表示。math模块中的常量和函数主要分为以下几类：

1、常量：包括math.pi、math.e等，用于表示圆周率π和自然常数e等常量。

        math.pi：表示圆周率π，值为3.14159265358979323846。

        math.e：表示自然常数e，值为2.71828182845904523536。

        math.inf：表示正无穷大，可以用于表示一些无穷大的数值。

        math.nan：表示不是一个数字（NaN），可以用于表示一些无法表示的数值，比如：0除以0的结果。

        math.tau：表示圆周率π的两倍，值为6.28318530717958647693。

import math
 
# 输出：3.141592653589793 2.718281828459045 inf nan 6.283185307179586
print(math.pi, math.e, math.inf, math.nan, math.tau)

2、算术函数：包括abs(x)、floor(x)、ceil(x)等，用于进行取整、取模等运算。

        math.fabs(x)：返回x的绝对值。

        math.floor(x)：返回x的向下取整值，即不大于x的最大整数。

        math.ceil(x)：返回x的向上取整值，即不小于x的最小整数。

        另外，Python还存在全局的abs()函数和round()函数。

        abs(x)：返回x的绝对值。

        round(x[, n])：返回x的四舍五入值，如果指定了n，则返回x保留n位小数的四舍五入值。

import math
 
# 输出：66.0
print(math.fabs(-66))
# 输出：-3
print(math.floor(-2.3))
# 输出：10
print(math.ceil(9.4))
 
# 输出：66
print(abs(-66))
# 输出：9.64
print(round(9.637, 2))

3、幂函数和对数函数：包括pow(x,y)、math.exp(x)、math.log(x)等，用于进行乘方、指数、对数等运算。

        math.pow(x, y)：返回x的y次方。

        math.exp(x)：返回e的x次方，e为自然常数。

        math.log(x[, base])：返回x的自然对数（以e为底），如果指定了base，则返回x的以base为底的对数。

        math.log10(x)：返回x的以10为底的对数。

        math.log2(x)：返回x的以2为底的对数。

        注意：在计算对数时需要指定底数，否则会报错；另外，对数的底数必须是正数，否则也会报错。

import math
 
# 输出：125.0
print(math.pow(5, 3))
# 输出：7.38905609893065
print(math.exp(2))
# 输出：2.0
print(math.log(36, 6))
# 输出：3.0
print(math.log10(1000))
# 输出：10.0
print(math.log2(1024))

4、三角函数：包括sin(x)、cos(x)、tan(x)等，用于进行正弦、余弦、正切等三角函数运算，x的单位是弧度。

        math.sin(x): 计算正弦值，参数x是弧度值。

        math.cos(x): 计算余弦值，参数x是弧度值。

        math.tan(x): 计算正切值，参数x是弧度值。

        math.asin(x): 计算反正弦值，参数x是-1到1之间的数值。

        math.acos(x): 计算反余弦值，参数x是-1到1之间的数值。

        math.atan(x): 计算反正切值，参数x是任意实数。

        math.atan2(y, x): 计算反正切值，参数y和x是坐标值，返回[-π, π]之间的弧度值。

import math
 
# 输出：1.0
print(math.sin(math.pi / 2))
# 输出：6.123233995736766e-17
print(math.cos(math.pi / 2))
# 输出：-1.2246467991473532e-16
print(math.tan(math.pi))
# 输出：1.5707963267948966
print(math.asin(1))
# 输出：0.0
print(math.acos(1))
# 输出：0.7853981633974483
print(math.atan(1))
# 输出：0.7853981633974483
print(math.atan2(6, 6))

5、角度转换函数：包括math.radians(x)、math.degrees(x)等，用于进行角度和弧度的转换。

        math.radians(x)：这个函数将角度转换为弧度。x是以度为单位的角度值，函数返回对应的弧度值。

        math.degrees(x)：这个函数将弧度转换为角度。x是以弧度为单位的弧度值，函数返回对应的角度值。

import math
 
# 将角度转换为弧度
angle_in_radians = math.radians(45)
# 输出：0.7853981633974483
print(angle_in_radians)
  
# 将弧度转换为角度
angle_in_degrees = math.degrees(math.pi / 2)
# 输出：90.0
print(angle_in_degrees)

6、双曲函数：包括math.cosh(x)、math.sinh(x)等，用于进行双曲函数的运算。

        math.sinh(x)：计算x的双曲正弦值。

        math.cosh(x)：计算x的双曲余弦值。

        math.tanh(x)：计算x的双曲正切值。

        math.asinh(x)：计算x的反双曲正弦值，也称为双曲正弦函数的逆函数。

        math.acosh(x)：计算x的反双曲余弦值，也称为双曲余弦函数的逆函数。

        math.atanh(x)：计算x的反双曲正切值，也称为双曲正切函数的逆函数。

import math
  
# 输出：1.1752011936438014
print(math.sinh(1.0))
# 输出：1.5430806348152437
print(math.cosh(1.0))
# 输出：0.7615941559557649
print(math.tanh(1.0))
 
# 输出：0.881373587019543
print(math.asinh(1.0))
# 输出：0.0
print(math.acosh(1.0))
# 输出：0.5493061443340549
print(math.atanh(0.5))

7、特殊函数：包括math.sqrt(x)、math.fmod(x,y)等，用于进行开方、取余等运算。

        math.fmod(x, y)：返回x除以y的余数，即：x mod y。

        math.modf(x)：返回x的整数部分和小数部分，即：(math.floor(x), x - math.floor(x))。

        math.sqrt(x)：返回x的平方根。

        math.factorial(x)：返回x的阶乘，即：x!。

        math.gcd(a, b)：返回a和b的最大公约数。

        math.lcm(a, b)：返回a和b的最小公倍数。

import math
  
# 输出：1.0
print(math.fmod(9, 4))
# 输出：(0.125, 8.0)
print(math.modf(8.125))
# 输出：25.0
print(math.sqrt(625))
# 输出：3628800
print(math.factorial(10))
# 输出：4
print(math.gcd(36, 64))
# 输出：576
print(math.lcm(36, 64))

random模块

1、random模块导入

import random

2、random()用于生成一个0到1的随机浮点数

random.random()

3、seed(n)用于设定种子值，其中n可以是任意数字，random()生成随机数的时候，每一个数字都是随机的，但使用seed(n)设定种子值后，先调用seed()，在使用random()，生成的随机值将是相同的，看下面代码示范。

random.seed(3)
 
random.random()
 
random.seed(3)
 
random.random()

4、uniform(a,b)用于返回a,b之间的随机浮点数，如a<=b则返回[a,b]范围内，如a>=b则返回[b,a]范围内，a和b可以是实数，浮点数，负数。

random.uniform(5,15)
 
random.uniform(5.5,15.9)
 
random.uniform(-5.5,15.9)

5、randint()返回a,b之间的整数，范围[a,b],要注意的是，传入的参数必须是整数，然后a一定要比b小。

random.randint(3,9)  ###传入a为3，b为9的整数
 
random.randint(9,3)  ###传入a为9，b为3的整数

6、randrange(start,stop)返回start到stop内的整数，可以设置step，注意 只能传入整数。

random.randrange(10,30)
 
random.randrange(10,50,4)
 
random.randrange(10,50,4)