python array 语法_Python基础及语法（二）

Python内存管理

内存是宝贵的，Python编程中一般无须关心变量的存亡，一般也不关心内存的管理，Python引用计数记录所有对象的引用数，当对象引用数为0时，它就被垃圾回收GC。

Python查看引用计数

1 importsys2 print(sys.getrefcount([]))3 x =[]4 print(sys.getrefcount(x))5 y =x6 print(sys.getrefcount(x))7 z =y8 print(sys.getrefcount(x))

随机数

random模块

1 importrandom2 print([random.randint(1, 5) for i in range(20)]) #randint随机在[1,5]区间内获取一个整数。

3 print([random.randrange(1, 5, 2) for i in range(20)]) #randrange随机在[1,5)区间内步频2里获取一个整数。

4 ls = list(range(1, 10, 2))5 print([random.choice(ls) for i in range(20)]) #choice随机在一个可迭代对象里获取一个随机元素。

6 print(random.choices(ls, k=20, weights=(1, 1, 1, 1, 10))) #choices随机在一个可迭代对象重复获取k个元素，可设置权重weights。

7 random.shuffle(ls) #shuffle就地打乱列表元素

8 print(ls)9 print(random.sample(ls, 3)) #sample随机获取可迭代对象内不重复的若干个元素。

列表list()

Python中list()用顺序表实现

list()中各个个体称作元素

元素可以是任意类型对象

列表内元素有序，可以使用索引

线性的结构

使用'[ ]'表示

列表是可变的

初始化：

1 ls1 =[]

2 ls2 =list()

3 ls3 = [1, '2', [3, 'a'], (4, 5)]

4 ls4 = list(range(5))

索引

索引也叫下标，正索引从左到右从0开始数起，负索引从右到左从-1开始数起。索引不可超界，否则报错。

增

1 ls = [1]

2 print(ls)

3 ls = [1] + [2] # 列表拼接

4 print(ls)

5 ls.append(3) # 在尾部增加一个元素

6 print(ls)

7 ls.extend([4, 5]) # 在尾部增加多个元素

8 print(ls)

9 ls.insert(3, 6) # 在索引3前插入元素6,如果超过索引范围则在头或尾插入元素(不推荐使用)

10 print(ls)

11 ls = ls * 2 # 列表重复n次拼接

12 print(ls)

删

1 ls = list(range(2, 11, 2)) # 定义2-10偶数列表

2 print(ls) # [2, 4, 6, 8, 10]

3 ls.remove(4) # 删除从左到右第一个指定value的元素

4 print(ls) # [2, 6, 8, 10]

5 ls.pop(1) # 删除指定index的元素

6 print(ls) # [2, 8, 10]

7 ls.pop() # 没有指定index，删除最后一个元素(推荐使用)

8 print(ls) # [2, 8]

9 ls.clear() # 清空列表元素

10 print(ls) # []

改

1 a = [1, 2, 3]

2 a[2] = 5 # 把索引2的元素改为5

查

1 ls = [1, 2, 3]

2 print(ls[1]) # 通过索引查找元素

3 print(ls.index(2)) # 通过元素查找索引

4 print(ls.count(3)) # 通过元素查找出现次数

5 print(len(ls)) # 返回列表长度

注意

浅拷贝和深拷贝的区别

1 importcopy

2 ls = [1, 2, [3, 4]]

3 ls1 =copy.copy(ls)

4 ls2 =copy.deepcopy(ls)

5 ls3 =ls.copy()

6 print(ls, ls1, ls2, ls3)

7 ls[2][1] = 100

8 print(ls, ls1, ls2, ls3)

Python在普通的拷贝中使用浅拷贝，仅仅拷贝一个引用地址，如果修改原始列表里面元素是列表的里面的内容，普通的拷贝会导致后面赋值的新列表会跟着改动，如需进行深拷贝，可使用copy.deepcopy()方法。

线性数据结构

是一组有序的元素的抽象，它由0个或有限个组成。

常见的线性结构有：

顺序表：用一块连续的存储空间有序分布，比如一条排队购票的队伍，可以插队，离队，可以被索引。

链接表：在存储空间分散分布，但是相邻元素有关联地链接起来，比如操场上手拉手随意站着的小朋友，也可以插队，离队，可以被索引。

栈Stack：后进先出，好像从下往上叠放的碟子，最后放上去的最先被拿起。

队列Queue：先进先出，好像一条站在闸道排队购票的队伍，不能插队离队，先排队的先购票。

元组tuple

一个有序的元素组成的集合，使用小括号()表示，不可变对象。

初始化

1 t1 =()2 t2 = (1,)3 t3 = (1,)*2

4 t4 = (1, 2)5 t5 = 1, 2

6 t6 =tuple()7 t7 = tuple(range(5))8 t8 = tuple([1, 2])

索引与增删改查

索引与查跟列表list一样。

因元组是不可变对象，无法实现增删改。

冒泡排序

1 importrandom2 arr = random.choices(range(1, 101), k=20)3 print(arr)4 for i in range(len(arr)-1, 0, -1):5 flag =False6 for j inrange(0, i):7 if arr[j] > arr[j+1]:8 arr[j], arr[j+1] = arr[j+1], arr[j]9 flag =True10 if notflag:11 break

12 print(arr)

总结

时间复杂度O(n²)，不是最优的排序算法。

字符串

一个个字符组成的有序的序列，是字符的集合。

使用单引号，双引号，三引号引住的字符序列。

字符串是不可变对象，是字面常量。

Python3起字符串都是Unicode类型。

初始化

1 s1 = '"'

2 s2 = "'"

3 s3 = '''a4 b'''

5 s4 = """c6 d"""

7 s5 = r'\n'

8 s6 = R'\t'

9 s7 = f'{s1}and{s2}'

增删改查与索引

和元组一样可索引可查找，不可修改。

拼接

1 s1, s2 = 'abc', 'def'

2 s3 = s1+s2 #s1与s2拼接起来生成一个全新的字符串

3 s4 = '!'.join(map(str, range(5))) #join用'!'(可替换)作为分隔符拼接起来重新生成一个全新的字符串

字符查找

1 s1 = 'abcdef'

2 print(s1.find('cd', 1, 4)) #从左向右查找返回查找字符的正索引,没有找到返回-1,可设置启示结尾的索引,可超界。

3 print(s1.rfind('g', -100, 200)) #从右向左查找返回查找字符的正索引,没有找到返回-1,可设置启示结尾的索引,可超界。

分割

s1 = '\t\r \nab\ncd\nef \n\r'

print(s1.split('c')) #从左向右按指定字符切割,可指定切割次数在,返回列表。

print(s1.rsplit('\n', 1)) #从右向左按指定字符切割,可指定切割次数,返回列表。