文章目录
- 数值
- 分类
- 2. 类型转换
- 3. 数字的处理函数
- 4. 类型判断
- 五 . 列表
- 索引访问
- 列表查询
- 列表增加,删除元素
- 1. `尾部`追加append()
- 2. `插入` insert()
- 3. extend(iteratable)尾部追加,元素
- 4. `+ -> list`
- 5. `*-->list` 浅拷贝
- 6. copy拷贝
- .深拷贝copy.deepcopy
- 7. 删除列表元素remove(),pop(),clear()
- 其他操作,反转,排序,in
- 六. 随机数random
- 练习
- Set(集合):
- Dictionary(字典):
- 七. 元组 tuple
- 元组的访问
- 八. 命名元组namedtuple
- 访问
- 冒泡排序
数值
Python3 的六个标准数据类型中:
不可变数据(3 个):Number(数字)、String(字符串)、Tuple(元组);
可变数据(3 个):List(列表)、Dictionary(字典)、Set(集合)。
分类
- 数值型
整数int
浮点数float
复数complex: 1+2j 或 1+2J
布尔 bool - 序列对象
字符串str
列表list
tuple 元组 - 键值对
集合set
字典dict
2. 类型转换
int() 强制转换为整数
float() 返回一个浮点数
complex(x),complex(x,y) 返回一个复数
bool(x) 返回布尔值
3. 数字的处理函数
round()
四舍六入五取偶
, 必须大于
0.5才会入,取偶数(理他最近的偶数)math.floor()
向下取整,需要导入math
包5/2=2math.ceil()
向上取整,5/2=3int()
只取整数部分//
整除且向下取整
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. 类型判断
-
type(a)
判断类型
type(1)
type(a)
type(bin(10)) == str
type(123) == int
-
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
列表查询
- index()—》不存在就会报错
根据值
,查询索引位置:从左向右找
时间复杂度最高为O(n)
#[stop]可有可无
index(value,[start,[stop]])
如果不存在,就会出现ValueError
a1=[1,2,3,4,5,6,7]
a1.index(1) # 0
- 计数 count()
不常用
-----> 不会报错
找里面有几个对应的数(将列表种的元素都查询一边
)
效率低
时间复杂度O(n)
a1=[1,2,3,4,1,6,1]
a1.count(1) # 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()
取内存地址
- 浅拷贝 :不会追踪
拷贝的是表面上的内容
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()
remove(value)
从左至右查找第一个匹配的值
返回None
如果删除前面的元素,后面的都得向前移动,效率差
效率O(n)
pop([index])
弹出
不指定索引index,就从列表尾部弹出一个元素
指定索引index,就从索引处弹出一个元素,如果索引超界IndexError
错误- 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
- reverse 反转
将所有的元素倒过来,返回None,
就地修改
建议用索引倒着读
- 排序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) #倒着排序
- 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中随机选出一个数,steprandom.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]
- index(value,[start,[stop]])
通过value,从指定区间查找元素
匹配不到就会返回ValueError
时间复杂度O(n)
- count(value)
返回表中value的次数
时间复杂度O(n)
- 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个数,排序后打印
- 用if,速度快,但是
繁琐
- 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)
- 用列表的sort方法,自建函数(
效率O(n)
)
就地修改,没有返回值
a=[42,124,65,23,90]
a.sort()
print(a)
- 用冒泡排序:
最优
冒泡法—交换排序
两两比较大小,交换位置
分为升序
和降序
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次数
优化
总结
链表:
栈:有序,
队列:有序