python内置数据结构

数据类型：

数值型

  • int
  • float
  • complex
  • bool

序列对象

  • 字符串 str
  • 列表 list
  • 元组 tuple

键值对

  • 集合 set
  • 字典dict

数值型：

  • int、float、complex、bool都是class，1、5.0、2+3j都是对象既实例
  • int：python3的int就是长整型，且没有大小限制、受限于内存区域的大小
  • float：有整数部分和小数部门组成，支持十进制和科学计数法表示，只有双精度型。
  • complex：有实数和虚数部分组成，实数部分和虚数部分都是浮点型。3+4.2j
  • bool：int的子类，仅有2个实例True、False对应1和0，可以和整数值直接运算

类型转换：

  • int(x) 返回一个整数
  • float(x) 返回一个浮点数
  • complex(x)、complex(z,y) 返回一个复数
  • bool(x) 返回一个布尔值，前面讲过False等价对象

数字处理函数：

import math
#向下取值，地板
print(math.floor(2.5),math.floor(-2.5)) 
#向上取值，天花板
print(math.ceil(2.5), math.ceil(-2.5))  
#测试四舍六入五取偶
print(round(3.5), round(3.5001), round(3.6), round(3.3))
#判断类型，但会一个bool值
print(isinstance(6, str))
print(isinstance(6, (str, bool, int)))
  • round()，四舍六入五取偶
  • floor(),向下取整，ceil()，向上取整
  • int(),取整
  • // 取整且向下取整
  • min() 最小值
  • max() 最大值
  • pow(x,y) 等于x**y
  • math.sqrt() 平方函数
  • bin(x) 二进制 返回值是字符串
  • oct(x) 八进制 返回值是字符串
  • hex(x) 十六进制 返回值是字符串
  • math.pi  π
  • math.e 自如常数

类型判断

  • type(obj) ,返回类型，而不是字符串
  • isinstance(obj, class_or_tuple)，返回一个bool值

 

序列对象

列表（list）

  •  一个队列，一个排列整齐的队伍
  • 列表内的个体称作元素，由若干元素组成列表
  • 元素可以是任意对象（数字、字符串、对象、列表等）
  • 列表内元素有顺序，可以使用索引
  • 线性的数据结构
  • 使用[]表示
  • 列表是可变的
  • 列表list、链表、queue、stack的差异

 列表list定义

  • list()
  • list(iterable)
  • 列表不能一开始定义大小
lst = list()
lst = []
lst = [2,6,9,'ab']
lst = list(range(5))

列表索引访问

  • 索引、也叫下标
  • 正索引：从左到右，从0开始为列表中每一个元素编号
  • 负索引：从右到左，从-1开始
  • 正负索引不可以超界，否则引发异常IndexError
  • 为了理解方便，可以认为列表是从左到右排列的，左边是头部，右边是尾部，左边是下界，右边是上界。
  • 列表通过索引访问    list[index] ,index就是索引，使用中括号访问

 列表查询

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

  • 通过值value,从指定区间查找列表内的元素是否匹配
  • 匹配第一个就立即返回索引
  • 匹配不到，抛出异常ValueError

count(value)

  • 返回列表中匹配value的次数

时间复杂度

  • index和count方法都是O(n)
  • 随着列表数据规模的增大，而效率下降

如何返回列表元素的个数？如果遍历？如何设计高效？

  • len()

列表元素修改

索引访问修改

  • list[index] = value
  • 索引不要超界
l = [1,2,3,4,5]
l[3] = "jaxzhai"
l

列表增加、插入元素

append(object) ->None

  • 列表尾部追加元素、返回None
  • 返回None就意味着没有新的列表产生，就地修改
  • 时间复杂度是O(1)

insert(index,object) -> None

  •  在指定的索引index处插入元素object
  • 返回None就意味着没有新的列表产生，就地修改
  • 时间复杂度是O(n)
  • 索引能超越上下界吗？
    • 超越上界，尾部追加
    • 超越下界，头部追加

extend(iteratable) -> None

  • 将可迭代对象的元素追加进来，返回None
  • 就地修改

+ -> list

  • 连接操作，将两个列表连接起来
  • 产生新的列表，源列表不变
  • 本质上调用的是_add_()方法

* -> list

  • 重复操作，将本列表元素重复N次，返回新的列表

列表删除元素

remove(value) -> None

  •  从左至右查找第一个匹配value的值，移除该元素，返回None
  • 就地修改
  • 效率慢（因为要查找这个值， 如果这个值是最后一个值，这时候已经遍历了一遍列表了）

pop([index]) -> item

  • 不指定索引index,就从列表尾部弹出一个元素
  • 指定索引index,就从索引处弹出一个元素，索引超界抛出IndexError错误
  • 效率？不指定索引的话效率会高，指定索引的话效率会低

clear() -> None

  •  清除列表所有元素，剩下一个空列表

列表其它操作

reverse() -> None

  • 将列表元素反转，返回None
  • 就地修改

sort(key=None,reverse=False) -> None

  • 对列表元素进行排序，就地修改，默认升序
  • reverse为True,反转，降序
  • key一个函数，指定key如何排序

in

  • [3,4] in [1,2,[3,4]]
  • for x in [1,2,3,4]

列表复制

lst0 = list(range(4)) 
lst2 = list(range(4)) 
print(lst0==lst2) 
lst1 = lst0
lst1[2] = 10 
print(lst0)
  •  lst0和lst2的内容是相等,内存地址不同。
  • lst1和lst0的内容相等，内地地址也相同

copy() -> list

  • shadow copy(浅拷贝)一个新的列表

浅拷贝

  • 影子拷贝，遇到引用类型，只是复制一个引用而已。（例如列表，字典等。既引用同样的内存地址）

深拷贝

  • copy模块提交了deepcopy

 

import copy
lst0 = [1, [2, 3, 4], 5]
lst5 = copy.deepcopy(lst0)
lst5[1][1] = 20
lst5 == lst0


这个执行结果就是False

 随机数

random模块

  • randint(a,b) 返回[a,b]之间的整数
  • choice(seq) 从非空的元素序列中随机挑选一个元素，例如：random.choice(range(10)),从0到9中随机挑选一个整数。
  • randrange([start],stop,[step])从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1。random.randrange(1,7,2)
  • random.shuffle(lsit) -> None 就地打乱列表顺序。
  • sample(population,k)从样本中随机取出k个不同的元素，返回一个新列表。
posted @ 2019-05-28 15:03  大胖猴  阅读(326)  评论(0)  编辑  收藏  举报