1.1数值型
int(x) 返回一个整数
float(x) 返回一个浮点数
complex(x)、complex(x,y) 返回一个复数
bool(x) 返回布尔值,前面讲过False等价的对象
1.2对象函数的处理
round(),总结:四舍六入,5取偶(最近的偶数)
print(round(2.5)) #2
print(round(2.5001)) #3
print(round(2.6)) #3
print(round(-2.5)) #-2
print(round(-2.5001)) #-3
print(round(-2.6)) #-3
int(),总结只取整数部分
print(int(3.5)) #3
print(int(3.4)) #3
print(int(3.6)) #3
//整除,总结整除并且向下取整
print(7//2, 7//-2, -7//2, -(7//2)) #3 -4 -4 -3
print(2//3, -2//3, -1//3) #0 -1 -1
math模块总结 floor()向下取整 ,ceil()向上取整
print(math.floor(2.5), math.floor(-2.5)) #2 -3
print(math.ceil(2.5), math.ceil(-2.5))#3 -2
1.3数字处理函数
max(...)
max(iterable, *[, default=obj, key=func]) -> value
max(arg1, arg2, *args, *[, key=func]) -> value
min(...)
min(iterable, *[, default=obj, key=func]) -> value
min(arg1, arg2, *args, *[, key=func]) -> value
pow(x, y, z=None, /)
Equivalent to x**y (with two arguments) or x**y % z (with three arguments)
文档上说使用三个参数时更高效
math.sqrt()
sqrt(...)
sqrt(x)
Return the square root of x.
1.4类型判断
type:返回类型,而不是字符串
type(object_or_name, bases, dict)
type(object) -> the object's type
type(name, bases, dict) -> a new type
type隐式转换
type(1+True) #返回int
isinstance:相比于type可以判断子类
isinstance(obj, class_or_tuple, /)
Return whether an object is an instance of a class or of a subclass thereof.
A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to
check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)
or ...`` etc.
i.e:
isinstance(6, (str, bool, int))
1.5列表
1.5.1列表特性
一个队列,一个排列整齐的队伍
列表内的个体称作元素,由若干元素组成列表
元素可以是任意对象(数字、字符串、对象、列表等)
列表内元素有顺序,可以使用索引
线性的数据结构
使用 [ ] 表示
列表是可变的
1.5.2列表定义
list() -> new empty list
list(iterable) -> new list initialized from iterable's items #迭代器也是可迭代对象,所以也能放迭代器
lst = list()
lst = []
lst = [2, 6, 9, 'ab']
lst = list(range(5))
1.5.3列表索引访问
lst = [1,3,5,7,9,'a','b','c','d']
索引,也叫下标
正索引:从左至右,从0开始,为列表中每一个元素编号
负索引:从右至左,从-1开始
正负索引不可以超界,否则引发异常IndexError
为了理解方便,可以认为列表是从左至右排列的,左边是头部,右边是尾部,左边是下界,右边是 上界
访问方式:
list[index] ,index就是索引,使用中括号访问
lst[-1] #'d'
lst[1] #3
lst[0:4] #[1, 3, 5, 7]
lst[-4:] #['a', 'b', 'c', 'd']
1.5.4列表查询
lst = [1,3,5,7,9,'a','b','c','d']
index(value,[start,[stop]]) --->return first index of value.
1.通过值value,从指定区间查找列表内的元素是否匹配
2.匹配第一个就立即返回索引
3.匹配不到,抛出异常ValueError
lst.index('a',1,6) #output 5
lst.index('a',-9,-3) #output 5
总结index按照从左到右的顺序查找,所以负数的时候也要按照次顺序查找
count(value) -> integer -- return number of occurrences of value
返回列表中匹配value的次数
时间复杂度
1.index和count方法都是O(n)
2.随着列表数据规模的增大,而效率下降
如何返回列表元素的个数?如何遍历?如何设计高效?
len() --->Return the number of items in a container;类似于计数器
1.5.5列表元素修改
索引访问修改
list[index] = value #通过下表对值重新赋值
lst[5]="aaaa" #索引不要超界
1.5.6列表增加插入元素
append(object) -> None -- append object to end
1.列表尾部追加元素,返回None
2.返回None就意味着没有新的列表产生,就地修改
3.时间复杂度是O(1)
lst.append('e')
insert(index, object) -- insert object before index
1.在指定的索引index处插入元素object
2.返回None就意味着没有新的列表产生,就地修改
3.时间复杂度是O(n) p
4.索引能超上下界吗?
1.超越上界,尾部追加
2.超越下界,头部追加
1.5.6列表增加插入元素
extend(...) method of builtins.list instance
L.extend(iterable) -> None -- extend list by appending elements from the iterable
1.将可迭代对象的元素追加进来,返回None
2. 就地修改
ie:
lst.extend(range(10,20,2))
+ -> list
1.连接操作,将两个列表连接起来
2.产生新的列表,原列表不变
3.本质上调用的是__add__()方法
ie:
lst5=[1,2,3,4]
lst6=['a',['b','c']]
lst7=lst4+lst5 #output[1, 2, 3, 4, 'a', 'b']
lst7[0]=100
lst7 #output[100, 2, 3, 4, 1, 2, 3, 4]
lst4 #output[1, 2, 3, 4]
* -> list
1.重复操作,将本列表元素重复n次,返回新的列表
ie:
lst2 = ['a','c',[1,2]]*2 #output['a', 'c', [1, 2], 'a', 'c', [1, 2]]
lst2[0]='aaaaa' #output['aaaaa', 'c', [1, 2], 'a', 'c', [1, 2]]
lst2[2][0]=11111 #output['aaaaa', 'c', [11111, 2], 'a', 'c', [11111, 2]]
总结简单的object,list重复n次的时候,重复项已经独立出来了,更改一个 ,不会全部变
复杂的object,list中嵌套list,重复项未独立出来,更改嵌套的list中一个值,全部变化
1.5.7列表删除元素
remove(...) method of builtins.list instance
L.remove(value) -> None -- remove first occurrence of value.
Raises ValueError if the value is not present
1.从左至右查找第一个匹配value的值,移除该元素,返回None
2. 就地修改
3.效率是O(n)
pop(...) method of builtins.list instance
L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
1.不指定索引index,就从列表尾部弹出一个元素
2.指定索引index,就从索引处弹出一个元素,索引超界抛出IndexError错误
3.效率,制定索引O(n),不指定索引O(1)
clear(...) method of builtins.list instance
L.clear() -> None -- remove all items from L
1.清除列表所有元素,剩下一个空列表
2.频繁clear会造成内存gc,当list太大是会影响性能
1.5.8列表的其他操作
reverse(...) method of builtins.list instance
L.reverse() -- reverse *IN PLACE*
1. 将列表元素反转,返回None
2.就地修改
class reversed(object)
reversed(sequence) -> reverse iterator over values of the sequence
Return a reverse iterator
ie:
tmp = reversed(lst)
tmp #output <list_reverseiterator at 0x7fdef40fc4e0>
for i in tmp:
print(i)
总结
在查询帮助文档的时候会显示function,method 再此以reverse()和reversed()做(i,e)
reverse是method;与类和实例有绑定关系的function都属于方法(method)定义的lst是一个类的实例,所以可以调用lst.reverse()
reversed()是function,与类和实例无绑定关系的function都属于函数(function),函数一般需要传递一个参数,所以可以调用reversed(lst)
reversed 返回一个iterator,all of iterator is iterable,list函数传递一个iterable,所以可以传递迭代器iterator作为参数,可以打印reversed的值了
1.5.9列表排序操作
sort(...) method of builtins.list instance
L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
true 1 false 0
1.对列表元素进行排序,就地修改,默认升序
2.reverse为True,反转,降序
3.key一个函数,指定key如何排序
lst.sort(key=functionname)
1.5.10 in
in 成员运算符
1 in [1,2,3,4,5,[2,3]]
返回True
[2,3] in [1,2,3,4,5,[2,3]]
返回True
1.5.11深浅copy
#浅copy的引用类型,引用的内存地址相同
lst3 = [1,[2,3],4,5]
lst4 = lst3.copy()
id(lst3[1])==id(lst4[1])