python2（数组列表）

数组列表

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

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

  列表（list）是python的内置数据类型，列表中元素的数据类型不必相同的。python本身并没有数组(array)类型，但是它的Numpy库中有数组(array)类型。而数组(array)中的元素数据类型必须全部相同。

  在列表（list）中保存的是数据的存放的地址，简单的说就是指针，并非数据，这样保存一个list就太麻烦了，例如list1=[1,2,3,'a']需要4个指针和四个数据，增加了存储开销和降低了访问效率。

序列通用操作

索引/角标

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

>>>arr[ 0 ]   #查找角标为0的数字

1

>>>arr[ 8 ]

9

>>>arr [ -1 ]  #倒数第1个

9

>>>arr [ -2 ]  #倒数第2个

8

>>>arr[ -100 ]  

报错不存在

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

切片书写形式：[ i : i + n : m ] （跟range(a , b , c)基本类似）

  其中i为切片的起始索引，为列表首位时可以忽略。i + n是列表的结束位置，为列表末位时可以忽略。索引范围为[i, i+n)，m可以不提供，默认值时1，不允许为0。当m为负数时，列表翻转。
  注意：这些值都可以大于列表的长度，不会报越界。但是会发生截断，就是仍然按照范围查找，但是超出序列数据范围部分，全部被遐想成空值，最终获取到空值进行忽略即可。

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

成员资格

python中序列成员资格指是检查某个元素是否是序列的成员

可以使用in关键字检查。（格式 ： 要检查的序列  in  指定序列）

>>> 1 in arr

True

>>> 10 in arr

False

长度与最值

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

最值问题

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
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 high < low:
        mid = -1
        break
    #元素不在范围内找不到
    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) #[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,3,4,1,2,3,1,1,2,0,0,1]
print(arr.count(1))  #5

#extend()
#在当前列表中，将传入的其他序列的元素添加在表尾
arr1 = [1,2,3]
arr2 = [4,5,6]
arr1.extend(arr2)
print(arr1)  #[1, 2, 3, 4, 5, 6]
"""
arr1.extend(7) 
TypeError: 'int' object is not iterable(可迭代的=序列)
"""

arr.extend("ABC")
print(arr1)

#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
"""
print(arr.index(10))
ValueError: 10 is not in list 找不到则报错
"""

#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()
#排序
arr = [4,2,5,2,6,2,7,9,4,7,2,7]
#arr.sort() 默认升序
arr.sort(reverse = True)  #降序
arr = ["ABC" , "123123123" , "我爱你中国" , "123123123" , "kasdkhas"]
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 比较的是对象地址
print(arr1)
print(arr2)
arr1[0] = 5
print(arr2[0]) #1
# 上述代码在arr1中修改元素 并不影响arr2
arr1 = [1,2,3,[4,5,6]]
arr2 = arr1.copy()
arr2[0] = 7
print(arr1[0]) #1
print(arr2[0]) #7
arr2[3][0] = 666
print(arr1[3]) #[666, 5, 6]
# 上述代码在arr2中修改元素 影响arr1
arr2[3] = [9,9,9]
print(arr1[3]) #[666, 5, 6]
print(arr2[3]) #[9, 9 , 9]

# 额外的知识
# del关键字：删除
arr = [1,2,3,4]
del arr[0] # 删除序列中的元素
print(arr) #[2,3,4]
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) #ABC
print(s2) ####ABC####

#count()
#和列表的count相似 统计字符串的个数
s = "abchjghjabcjkhjkhabchkjhabc"
print(s.count("abc")) #4
print(s.count("a")) #4
#count是非贪心算法 贪心统计6个
s = "AAAAAAAA"
print(s.count("AAA")) #2
print(s.count("AAA",2,6)) #1 从索引2到6

#endwith()
#过滤字符串结尾 同样也可以指定区间
s = "泷泽萝拉.avi"
print(s.endswith(".avi")) #True

#find()
#寻找字符串第一次出现的位置 同样也可以指定区间
s = "八百标兵奔北坡”
print(s.find("标兵“)) # 2 指定的是标的角标

#format()
#格式化输出
name = "小强”
age = 18
print("我的名字叫%s ， 年龄%d岁“ % （name ， age)) #我的名字叫小强, 年龄18岁
print("我的名字叫{}, 年龄{}岁".format(name, age)) #我的名字叫小强, 年龄18岁
print(f"我的名字叫{name}, 年龄{age}岁")  #我的名字叫小强, 年龄18岁
print(f"我的名字叫{3 > 2}, 年龄{2 ** 8}岁") #我的名字叫True, 年龄256岁

# index()
# 寻找字符串第一次出现的位置 同样也可以指定区间
s = "八百标兵奔北坡"
print(s.index("标兵")) # 2 指定是标的角标

s = "ABC"
print(s.find("D")) # -1 如果找不到 则返回-1
# print(s.index("D"))# 如果找不到 直接报错 ValueError: substring not found

#isalpha() 是否纯字母字符串
#isdecimal() 是否是十进制纯数字字符串
#isdigit() 是否纯数字字符串
#isspace() 是否纯空格字符串

#islower() 出现的字母是否是小写字母
print("123abc".islower())
print("123Abc".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

# lstrip()去除左边空格 rstrip()去除右边空格
print("     ABC       ".lstrip()) #ABC
print("     ABC       ".rstrip())
print("     ABC       ".strip()) # 两边都去掉连续空格
print("   A   B   C   ".strip()) #A   B   C

# 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) #['1', '2', '34', '4.12']

math模块：

常用的函数

• math.sqrt(x): 计算平方根
• math.pow(x, y): 计算x的y次方
• math.exp(x): 计算e的x次方（自然指数）
• math.log(x[, base]): 计算x的自然对数（base默认为e），如果指定了base，则计算以base为底的对数
• math.log10(x): 计算以10为底的对数
• math.sin(x), math.cos(x), math.tan(x): 计算正弦、余弦和正切值（输入角度需为弧度）
• math.asin(x), math.acos(x), math.atan(x), math.atan2(y, x): 计算反正弦、反余弦、反正切和从y/x组成的坐标得到的反正切（输入和输出均为弧度）
• math.ceil(x): 向上取整
• math.floor(x): 向下取整
• math.fabs(x): 返回x的绝对值
• math.factorial(x): 返回x的阶乘（x必须是整数和非负数）
• math.fmod(x, y): 返回x除以y的余数，浮点数版本
• math.gcd(a, b): 返回a和b的最大公约数
• math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0): 返回True如果a和b的值在绝对容差abs_tol或相对容差rel_tol之内
• math.isfinite(x): 如果x不是无穷大（正负）并且不是NaN（非数字），则返回True
• math.isinf(x): 如果x是正无穷大或负无穷大，则返回True
• math.isnan(x): 如果x是“不是数字”（NaN），则返回True
• ... 还有更多其他函数

常用的常量

• math.pi: 圆周率π的值
• math.e: 自然对数的底数e的值
• math.tau: 等于2π，用于某些数学和工程应用
• math.inf: 表示正无穷大的浮点数
• math.nan: 表示“不是数字”（Not a Number）的特殊浮点值

import math  
  
# 计算平方根  
print(math.sqrt(16))  # 输出 4.0  
  
# 计算对数  
print(math.log(100, 10))  # 输出 2.0  
  
# 计算正弦值（注意：角度需要转换为弧度）  
angle_radians = math.radians(45)  
print(math.sin(angle_radians))  # 输出接近 0.7071067811865476（即 sin(45度) 的值）  
  
# 计算阶乘  
print(math.factorial(5))  # 输出 120  
  
# 检查是否为无穷大或NaN  
print(math.isinf(math.inf))  # 输出 True  
print(math.isnan(math.nan))  # 输出 True

random模块

常用的函数

• random.random(): 返回一个[0.0, 1.0)之间的随机浮点数。

• x = random.random()  
  print(x)  # 例如：0.4710854715202344

• random.uniform(a, b): 返回一个在[a, b]之间的随机浮点数（包括a但不包括b）。

• x = random.uniform(1, 10)  
  print(x)  # 例如：4.56789012

• random.randint(a, b): 返回一个在[a, b]之间的随机整数（包括a和b）。

• x = random.randint(1, 10)  
  print(x)  # 例如：7

• random.randrange([start, ]stop[, step]): 返回一个在指定范围内的随机整数。默认从0开始，不包括结束值stop，可以指定步长step。

• x = random.randrange(1, 10)  
  print(x)  # 例如：3  
  x = random.randrange(0, 100, 10)  # 从0开始到100（不包括），步长为10  
  print(x)  # 例如：20

• random.choice(seq): 从非空序列seq中随机选择一个元素。

• x = random.choice([1, 2, 3, 4, 5])  
  print(x)  # 例如：3

• random.choices(population, weights=None, *, cum_weights=None, k=1): 从population中随机选择k个元素，可以有重复的。weights参数指定了每个元素的选择权重。

• x = random.choices([1, 2, 3, 4, 5], k=3)  
  print(x)  # 例如：[3, 4, 1]

• random.shuffle(x[, random]): 就地（in-place）打乱序列x中的元素。

• lst = [1, 2, 3, 4, 5]  
  random.shuffle(lst)  
  print(lst)  # 例如：[3, 5, 1, 4, 2]

• random.sample(population, k): 从population中随机选择k个不重复的元素。

• x = random.sample([1, 2, 3, 4, 5], 3)  
  print(x)  # 例如：[2, 4, 5]

• random.seed([a]): 初始化随机数生成器的种子。如果你需要每次运行程序时都得到相同的随机数序列，可以设置一个固定的种子值。

random.seed(1)  
x = random.random()  
print(x)  # 始终输出相同的随机数