（三）Python内置数据结构，函数，类型，列表（copy浅，深拷贝），随机数，元组，排序算法

数值

Python3 的六个标准数据类型中：

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；

可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

分类

1. 数值型
   整数int
   浮点数float
   复数complex： 1+2j 或 1+2J
   布尔 bool
2. 序列对象
   字符串str
   列表list
   tuple 元组
3. 键值对
   集合set
   字典dict

2. 类型转换

int() 强制转换为整数
float() 返回一个浮点数
complex(x)，complex(x,y) 返回一个复数
bool(x) 返回布尔值

3. 数字的处理函数

round() 四舍六入五取偶, 必须大于0.5才会入，取偶数（理他最近的偶数）
math.floor()向下取整，需要导入math包5/2=2
math.ceil()向上取整，5/2=3
int() 只取整数部分
//整除且向下取整

round(2.421) #2
round(12.5)  #12
round(2.5000) #2  离2.5最近的偶数为2
round(3.5)   #4   理3.5最近的偶数为4
math.ceil(-2.1)   #-2
math.ceil(-2.4999) #-2

math.floor(2.1)  # 3
math.floor(-2.21312) # -3

常用的数值函数
min(),
max()
pow(x,y) 等于 x**y
math,sqrt() 等于 x**0.5

math模块
math.pi 相当于∏
math.e自由常数
math模块中还有对数函数，三角函数等

min(2.4.6.8)  # 2
max(2.4.6.8)  #8
pow(2.3)   #8
math.sqrt(25)  #5

进制函数，返回的是字符串
bin()，返回二进制
oct（）八进制
hex() 十六进制

4. 类型判断

1. type(a)判断类型

	type(1)
	type(a)
	type(bin(10)) ==  str
	type(123)  == int

2. isinstance(obj,class_or_tuple)返回布尔值

isinstance('abc',str) #True
isinstance(123,int)  #True
isinstance('abc',int,float,bool) #False
isinstance('abc',int,float,bool,str) #True

五 . 列表

一个队列，连续的内存空间
列表内的个体称作元素，有若干个元素组成
元素可以是任意对象（数字，字符串，对象，列表等）
列表内的元素有顺序，可以使用索引
线性的数据结构
使用 [ ] 表示,如果是list（）表示里面的每一个字符都是一个元素
列表是可变的
可迭代

缺点：删除一个元素—其他元素都得搬家

list() 内建函数

a1=[]
a2=[1,2,'abc']
a3=list()    #空列表
a4=list(range(5))
a5=list[1,'abc',Ture,None,[4,5,'ber'],str]

索引访问

索引：也叫下表
正索引：从左至右，从0开始到i-1
负索引：从右至左，从-1开始
正负索引不可以超界，否则会引发IndexError异常

a1=[1,2,3,4,5,6,7]
print(a1[0])  #1
print(a1[6])  #7
print(a1[-1]) #倒数第一个 7

赋值

a1[0]=a1[0]+10   #a[0]=11

列表查询

1. index()—》不存在就会报错
   根据值，查询索引位置：从左向右找
   时间复杂度最高为O(n)

#[stop]可有可无

index(value,[start,[stop]])

如果不存在，就会出现ValueError

a1=[1,2,3,4,5,6,7]
a1.index(1)   # 0

2. 计数 count() 不常用-----> 不会报错
   找里面有几个对应的数（将列表种的元素都查询一边）
   效率低
   时间复杂度O(n)

a1=[1,2,3,4,1,6,1]
a1.count(1)   # 3

3. 长度len()
   计算列表长度,在列表创建，删除，增加的时候会自动记录
   时间复杂度为O(1)

a1=[1,2,3,4,1,6,1]
len(a1)   # 7

列表增加，删除元素

建议：append(),insert(),pop(),in

1. 尾部追加append()

append(object) —>None
返回None
时间复杂度为O(1)

a1=[1,2,3,4,1,6,1]
a1.append(3)    #返回None

2. 插入 insert()

 insert(index,object)

效率非常低
时间复杂度为O(n)
如果超出界限—就为首部，尾部

a1.insert(1,"nice")

3. extend(iteratable)尾部追加,元素

将可迭代对象的元素追加进来
返回值为None
效率O(1)

如果是一个字符串，则会将这个字符串的每一元素变成裂变的元素

a1.extend(range(100,103))

a1.extend([1,2,3])   #列表本身就是可迭代的

4. + -> list

连接操作
耗内存

b1 = a1 + [1,23,54,2]  #返回一个新的列表

5. *-->list 浅拷贝

重复操作，会改变长度 （len*3）
指向的是同一个内存地址，修改其一,都会导致所有指向同一地址的内容改变

a1本身不会变，
a2是重复的a1，相当于改变a1，a2种重复操作的内容都会改变

a1=[[1,2,3]]*3
a1=[[1,2,3],[1,2,3],[1,2,3]]
a1[2][2]=100
a1=[[1,2,100]，[1,2,100]，[1,2,100]]

6. copy拷贝

生成一个新的列表
id() 取内存地址

1. 浅拷贝 ：不会追踪
   拷贝的是表面上的内容

a1=[1,[2,3],4]
a2=a1.copy()	#a2=a1
a1[0]=2
a1 == a2  #False

如果是嵌套的列表
就会改变内存位置列表中的元素

a1=[1,[2,3],4]
a2=a1.copy()	#a2=a1
a1[1][1]=5    #a1=[1,[2,5],4]
a1 == a2  #True

绿色的：普通值
蓝色的：指向引用地址

* -->list 也是浅拷贝
在cPython中， id() 取内存中的地址

.深拷贝copy.deepcopy

深拷贝：会追踪，地址所指向的列表
也就是，会拷贝更深处的内容
需要导入一个模块 copy

import copy
a1=[1,[2,3],4]
a2=copy.deepcopy(a1)	#内容相等
a1[1][1]=5    #a1=[1,[2,5],4]
a1 == a2  #False，内容

7. 删除列表元素remove()，pop()，clear()

1. remove(value)
   从左至右查找第一个匹配的值
   返回None
   如果删除前面的元素，后面的都得向前移动，效率差效率O(n)

2. pop([index]) 弹出
   不指定索引index，就从列表尾部弹出一个元素
   指定索引index，就从索引处弹出一个元素，如果索引超界IndexError错误

3. clear()
   清除列表中所有的元素

a1=[1,2,3,4,5,6]
a1.remove(1)   #a1=[1,3,4,5,6]

a1.pip(3)  	#a1=[1,3,4,6]

a1.clear()   #a1=[]

其他操作,反转，排序，in

1. reverse 反转
   将所有的元素倒过来，返回None，
   就地修改
   建议用索引倒着读

2. 排序sort()
   必须是同类型
   对列表中的元素进行排序，默认升序
   reverse为True，反转，降序

key一个函数，将列表中的所有元素转换为function类型，再排序，仅用于比较，不影响元素本身

lst.sort(key=function)

a1=[23,50,12,1]
a1.sort()   #a1=[1,12,23,50]

a1.sort(key=int)    #将元素都转换为int类型

a1.sort(key=int,reverse=Ture)   #倒着排序

3. in
   查看该元素，包含 在列表中
   不会报错

a1=[1,2,3]
1 in a1  #Ture
a in a1   #False

a2=[1,[2,3],4] 
3 in a2      #False
[2,3] in a2   #Ture

print(10 in a)
  

六. 随机数random

需要导入import random

random.randint(a,b)返回[a，b]之间的数
random.choice(seq)从seq中随机选出一个数,step
random.randrange([start],stop,[]) 从指定范围中获取一个随机数
random.shuffle(list) 就地打乱列表元素,重新分配（就地修改）
random.sample(population,k)从样本空间取出k个不同元素（不会取相同的元素—必须是位置不同），反会一个新的列表，（不能超出样本总数）

#随机生成[1，2],结果随机1，2
random.randint(1,2)

#前包后不包[1,2，3}，结果只有1，2
random.randrange(1,2，3)

lst=list(range(1,10))   #1,,,9
#从这列表中随机取10个数
for i in range(10):
	print(random.choice(lst))
等价于
#从这列表中随机取10个数
for i in range(10):
	index=random.randint(0,9)
	print(lst[index]))

random.sample(lst,7)  #取lst中取出7个随机的数

random.sample([1,1,1],2)    #结果  [1,1]

练习

Set（集合）:

集合（set）无序且不重复的元素集合。两个广州在用print()输出就剩下一个广州。

arae = {‘广州’, ‘北京’, ‘上海’, ‘深圳’, ‘成都’, ‘杭州’,‘广州’}

Dictionary（字典）:

字典（dictionary）是Python中另一个非常有用的内置数据类型，小学查字典按拼音查找或者部首查找。python的字典按键值查找，‘name’:'小明’一对，‘sex’:'男’一对，‘age’:18一对，都是一一对应。

people = {‘name’: ‘小明’,‘sex’:‘男’, ‘age’:18}

七. 元组 tuple

一个有序的元素逐层的集合
使用小括号 () 表示，里面的数是可迭代
元素不可变，而列表可变

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号()里，元素之间用逗号隔开。可以看做保险箱，放进去的东西不可以修改

tuple = ( ‘a’, 16 , 2.85, ‘python’, 78.2 )

a1=()
a2=tuple()
a3=(1)*3   不是元组，1使用括号改变优先级
a4=(1,2)

a3=(1,)*3 #才是元组正确的写法


a5=(1,[2,3],'a',None)


a6=tuple(lst)    #将数据给元素（列表，可迭代）

a7=tupel(range(10))

a7[1]=123  #会报错----不可改变


a8=(1,[2,3],4)
a8[1][1]=100    #[]为元组 内存位置中的数据，所以可以改变
#结果a8=(1,[2,100],4])

元组的访问

类似于数组
支持索引（下标）
正索引，负索引（不能超过仅限）
没有（增删改方法）

tuple[index]

1. index(value,[start,[stop]])
   通过value，从指定区间查找元素
   匹配不到就会返回ValueError
   时间复杂度O(n)

2. count(value)
   返回表中value的次数
   时间复杂度O(n)

3. len(tuple)
   返回元素的个数
   时间复杂度O(1)

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

八. 命名元组namedtuple

namedtuple(typename,field_names,verbose=False,rename=False)

命名元组，返回一个元组的子类。并定义了字段
field_names可以是空白符，逗号，可以是字段的列表

用的是标识符，名称是用来看的

两种导入方式

1.导入
from collections  import namedtuple 

标识符			  类的名称   属性的名称
Point=namedtuple('Point',['x','y'])
p1=Point(4,5)
print(p1)  #

标识符			  类的名称   属性的名称
Point=namedtuple('Point',['x','y'])
Student = namedtuple('S','name age')
Student2 = namedtuple('S','name,age')

用的时候用标识符
tom =Student('tome',20)
xiaoming=Student('xm',18)

2.直接使用方法
collections.namedtuple()

访问

xiaoming=Student('xm',18)

冒泡排序

依次输入3个数，排序后打印

1. 用if，速度快，但是繁琐
   

2. max函数，效率低

a=[42,124,65,23,90]
l=len(a)
newlist=[]   #先占好位置
for i in range(l):
	m = max(a)
	#就算有相同的元素也不影响，排序嘛
	newlist.insert(0,m)
	a.remove(m)
print(newlist)

3. 用列表的sort方法，自建函数（效率O(n)）
   就地修改，没有返回值

a=[42,124,65,23,90]
a.sort()
print(a)

4. 用冒泡排序:最优

冒泡法—交换排序
两两比较大小，交换位置
分为升序和降序

a = [89,24,12,43,52,213,2314]
n=len(a)
print(a)
#比较几趟
for i in range(n):
    # 第i躺比较次数,第一次：8-i-1=7,也就是比较7次
    for j in range(n-i-1):
        if a[j]>a[j+1]:
            #交换
            temp = a[j]
            a[j] = a[j+1]
            a[j+1] = temp
print(a)

如果想要算出，共进行几趟用count，每趟用swap_count次数

优化

总结

链表：
栈：有序，
队列：有序