python内置数据

分类:
1.数值型
int, float, complex, bool 都是class(类) ,1，5.0,2+3j都是对象（实例）

int：py3中int就是长整型，无大小限制，受限于内存区域大小
float：由整数部分和小数部分组成。支持十进制和科学计数法。只有双精度型
comlex：由实数和虚数部分组成，实数和虚数都是浮点数，eg：3+4.2j
bool：int的子类，仅有2个实例True,False,对应1和0.可以和整数直接运算。

类型转换：
int（x）返回一个整数
float（x）返回一个浮点数
comlex（x），comlex（x，y）返回一个复数
bool（x）返回布尔值。

数字处理相关函数
round()，四舍五入
floor()（向下取整），ceil()（向上取整）
int（）取整数部分，和//（整除）一样

举例：
import math
print(math.floor(2.5))返回2
print(math.ceil(2.5))返回3
print(round(2.51))返回3
print(round(2.5))返回3
print(round(2.4))返回2
min()
max()
pow(x,y) 等价于x**y
math.sqrt()

bin() 返回一个整数 (int )的二进制表示
oct() 将一个整数转换成8进制字符串
hex() 将10进制整数转换成16进制，以字符串形式表示
math.pi π
math.e 自然常数
*注意: 进制函数返回值类型是字符串(str)

类型判断
type(obj),返回类型,而不是字符串
isinstance(obj,class_or_tuple),返回布尔值
举例:
type(a) 返回<class ‘int’>
type(‘abc’)返回<class ‘str’>
type(123)=<class ‘int’>
isinstance(6,str)=False
isinstance(6,(str,bool,int))=True[该语句希望判断6是否属于str,bool,int中任何一类]
(1+True)返回2
type(1+True)返回<class ‘int’>
(1+True+2.0)返回4.0(往高精度转)
type(1+True+2.0)返回<class ‘float’>(隐式转换)

类型比较:
a = 5
b = ‘123’
type(a) == str
False
type(b) == str
True

2.序列对象
字符串str
列表list
一个队列,有序的,可以用索引,可变的.
列表不能一开始就定义大小
形如list()或list(iterable)==>什么都不放或放入可迭代对象
列表内个体称为元素,由若干元素组成列表
元素可以使任意对象(数字 字符串 对象 列表等)
线性的数据结构
使用[]表示

常用表达方式:
lst = list()
lst = []
lst = [2,6,9,‘ab’]
lst = list(range(5))

列表索引访问
索引,也叫下标
正索引:从左至右, 从0开始为列表中每一个元素编号
负索引:从右至左,从-1开始
正负索引超界时会引发IndexError
列表通过索引访问.

列表查询:

• index(value,[start,[stop]])
  通过值vaule,从指定区间查找列表内的元素是否匹配
  匹配到第一个就立即返回索引
  匹配不到抛异常,VauleError
  eg:

  >>>a=[1,3,5,8,2,6]
  >>>a.index(3,3)
  Traceback (most recent call last):
    File "<pyshell#18>", line 1, in <module>
      a.index(3,3)
  ValueError: 3 is not in list
  >>>a=[1,3,5,3,2,6]
  >>>a.index(3,3)
  3
  >>>a=[1,3,5,2,3,2,6]
  >>>a.index(3,3)
  4
  >>>a.index(3,-1)
  Traceback (most recent call last):
  File "<pyshell#23>", line 1, in <module>
    a.index(3,-1)
  ValueError: 3 is not in list
  >>>a.index(6,-1)
  6
  >>>a.index(2,-1)
  Traceback (most recent call last):
    File "<pyshell#25>", line 1, in <module>
      a.index(2,-1)
  ValueError: 2 is not in list
  >>>a.index(2,-2)
  5
  >>>a.index(6,-2)
  6
  

• count(vaule)
  返回列表中匹配vaule的次数

• 时间复杂度(O)
  index和count方法都是O(n)
  是考量算法的重要指标.n代表有n个元素就需要扫描n次
  随着列表数据规模的增大而效率下降

• 如何返回列表元素的个数,如何遍历?如何设计高效?
  len()

列表增加,删除元素

• append(object) -> None#就地修改
  列表尾部追加元素,返回None

  a.append(9)#返回None
  a
  [1, 3, 5, 2, 3, 2, 6, 9]
  

返回None意味着没有新列表产生,就地修改
时间复杂度是O(1)#意思为一步就到位

• insert(index,object)->None#
  在指定的索引index处插入元素object(可能在头/尾/中间等任意位置)
  返回None意味着没有新列表产生,就地修改
  时间复杂度是O(1)
• 索引能超上下界吗:
  超越上界,尾部追加
  超越下界,头部追加
  eg:

>>>a.insert(10,45)
>>>a
[1, 3, 5, 2, 3, 2, 6, 9, 45]
>>>a.insert(-10,45)
>>>a
[45, 1, 3, 5, 2, 3, 2, 6, 9, 45]

列表增加,插入元素

• extend(iteratable) ->None
  将可迭代对象的元素追加进来,返回None
  就地修改
• ‘+’ ->list
  连接操作,将两个列表连接起来
  产生新的列表,原列表不变
  本质上是调用_add_()方法
• ‘*’ ->list
  重复操作,将本列表元素重复n次,返回新的列表

列表删除元素
remove(value) -> None
从左至右查找第一个匹配value的值,移除
就地修改
pop([index]) -> item
不指定索引index,就从列表尾部弹出一个元素
指定索引index,就从索引处弹出一个元素
clear() ->None
清除列表所有元素, 剩下一个空列表

列表其他操作

• reverse() ->None
  将列表元素反转,返回None
  就地修改
• sort(key=None,reverse=False) -> None
  对列表元素进行排序,就地修改,默认升序
  reverse为True,反转,降序
  key一个函数,指定key如何排序
  a.sort(key=functionname)

a.append('love')
>>> a.sort()
Traceback (most recent call last):
  File "<pyshell#39>", line 1, in <module>
    a.sort()
TypeError: '<' not supported between instances of 'str' and 'int'
>>> a.sort(key=int)
Traceback (most recent call last):
  File "<pyshell#40>", line 1, in <module>
    a.sort(key=int)
ValueError: invalid literal for int() with base 10: 'love'
>>> a.sort(key=str)
>>> a
[1, 2, 2, 3, 3, 45, 45, 5, 6, 9, 'love']
>>> a.sort(key=str,reverse=True)
>>> a
['love', 9, 6, 5, 45, 45, 3, 3, 2, 2, 1]

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

列表复制:
eg:

>>> lst0 = list(range(4))
>>> lst2 = list(range(4))
>>> lst0 == lst2
True
>>> lst1 = lst0
>>> lst1[2] = 10
>>> lst1[2]
10
>>> lst0[2]
10

==:比较二者内容是否完全相等
is:比较二者内存地址id list是否相等

hash(哈希):
Hash(散列)就是把任意长度的输入通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。
HASH主要用于信息安全领域中加密算法，他把一些不同长度的信息转化成杂乱的128位的编码里,叫做HASH值. 也可以说，hash就是找到一种数据内容和数据存放地址之间的映射关系

整型可哈希.
list不可哈希.

copy() ->list

• shadow copy(影子拷贝),也叫浅拷贝返回一个新的列表

>>> lstt0 = list(range(4))
>>> lstt5 = lstt0.copy()
>>> lstt5 == lstt0
True
>>> lstt5[2] = 10
>>> lstt5 == lstt0
False
>>> lstt5
[0, 1, 10, 3]
>>> lstt0
[0, 1, 2, 3]

• 深拷贝:
  copy提供了deepcopy

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

[列表list,链表,queue,stack的差别]

链表:

在Python中，则可以采用“引用+类”来模拟实现链表。不是线性结构的,在内存中零散放置,需要地址才能确认位置.

链表的定义：是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的链接

链表的结构：data为自定义的数据，next为下一个节点的地址。

queue&stack:
队列(queue).有序的. 先进先出,
栈(stack)后进先出.也属于队列的一种

Queue是python标准库中的线程安全的队列（FIFO）实现,提供了一个适用于多线程编程的先进先出的数据结构，即队列，用来在生产者和消费者线程之间的信息传递.

随机数
random模块
randint(a,b)返回[a,b]之间的整数(闭区间)
choice(seq)从非空序列的元素中随机挑选一个元素,比如random.choice(range(10)),从0到9中随机挑选一个整数.

>>> random.choice(1,3,5,7)
Traceback (most recent call last):
  File "<pyshell#96>", line 1, in <module>
    random.choice(1,3,5,7)
NameError: name 'random' is not defined
>>> import random
>>> random.choice(1,3,5,7)
Traceback (most recent call last):
  File "<pyshell#98>", line 1, in <module>
    random.choice(1,3,5,7)
TypeError: choice() takes 2 positional arguments but 5 were given
>>> random.choice([1,3,5,7])
7
>>> random.choice([1,3,5,7])
1

randrange(start,stop,step)从指定范围内,按指定基数递增的集合中获取一个随机数,技术缺省值1.

>>>import random
>>>random.randrange(1,7,2)
5

random.shuffle(list) ->None 就地打乱列表元素

tuple
3. 键值对
集合set
字典dict