python数据类型

一、数值型

1、int

	int(x)

​ 返回整数类型。就是python的长整型，且没有大小限制，受限于内存区域的大小。

	int('a',16)

	# 返回值 10

2、float

	float(x)

​ 返回浮点数类型。由整数部分和小数部分组成。支持十进制和科学计数法表示。C的双精度型实现。

3、complex

	complex(x) complex(x,y)

​ 返回一个复数。由实数和虚数部分组成，实数和虚数部分是浮点数。eg:3+4.2J

4、bool

	bool(x)

​ 返回布尔值。int的子类，仅有2个实力Ture、False对应1和0，可以和整数直接运算。

​ 等价False的对象空字典，空元组，空列表，空集合，空字符串，none,0。

	1+False
	# 返回值 Ture

二、数字的处理函数

1、整除

1//2，3//2，5//2
# 返回值（0，1，2）

-1//2，1//-2
# 返回值（-1，-1）

int(x/x) #截取整数部分

​ 整除向下取整。

2、math模块

import matg # 导入模块
math.floor(x/x) # 向下取整
math.ceil(x/x) # 向上取整
math.sqrt(3) #开方
# 返回值 1.732050807508075688772
math.log2(4)
# 返回值 2.0

3、round

round(0) # 圆整 四舍六入五取偶

eg

round(2,5)
# 返回值2
round(-2,5)
# 返回值-2

三、类型判断

type

​ 返回类型，而不是字符串。

type(1) # 你是什么类型
# 输出为 int
type(1) = int 
# 输出结果为 Ture

isinstance

isinstance(obj,class_or_tuple) # 返回布尔值
isinstance('abc',str) # bool 'abc'是否为str
 # 输出为 Ture
isinstance('abc',(str,int,list))
 #返回值为 Ture

四、列表list

​ 列表 list 在内存中连续的结构 在数据尾部的更改没有影响，定位速度快可以插入元素，移除元素。容器都为可迭代对象。正索引从开始 负索引从-1开始 列表可变。

链表 linked list

​ 链表 linked list 单向链接，除值本身还有下一个值的地址 ，找第几个需要数，增减数据比较困难 上一个知道下一个在哪里，检索困难。

栈stack

​ 栈stack 摞盘子 后进先出LIFO (last in fast out)

队列queue

​ 队列queue 有栏杆的排队 先进先出 不能删除增加数据 基于列表或链表来实现， 遍历 所有那一遍 不重复。

五、列表查询

1、index

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

随着列表中元素的增加，这种index函数的效率下降 随着列表元素规模的增加，性能下降 有n个时间复杂度，O(n)。

2、count

count(value)
# 返回列表中匹配value 

​ 查找该元素出现过几次，会遍历找，O(n).

3、时间复杂度

​ index和count方法都是O(n)

​ 随着列表数据规模的增大，而效率下降。

六、列表元素的修改

1、索引访问修改

list[index]=value
# 索引不要超界，否则会报错
l1=[1,2,3,4]
l1[2] = 100
# 输出l1结果为
# [1,2,100,4]

2、列表增加、插入元素

1、append

append(object)->None
# 列表尾部追加元素，返回None
# 返回 None就意味着没有新的列表产生，原地修改
# 时间复杂度为O(1)
l1 = [1]
l1.append(2)
# 输出l1的结果为
# [1,2]

2、insert

insert(index,object)->None
# 在指定的索引index处插入元素object
# 返回None就意味着没有新的列表产生，就地修改
# 时间复杂度是O(n)
# 索引超上界，尾部追加
# 索引超下界，头部追加
l1 = [1,2]
l1.insert(1,0)
# 输出l1结果为
# [1,0]

3、extend

extend(iteratable)->None
# 将可迭代对象的元素追加进来，返回None
# 就地修改
l1 = [1,0]
l1.extend(range(2,5))
# 输出l1结果为
# [1,0,2,3,4]

​ extend 与append的区别是后者只能追加一个元素，而entend可以追加若干。

4、+ - list

l1 = [1]
l2 = [2]
l3 = l1+l2
# 输出结果l3结果为
# [1,2]

​ 连接操作，将两个列表连接起来

​ 产生新的列表，原列表不变

​ 本质上调用的是魔术方法add()方法

5、* - list

[1,2,3] * 5
# 返回值为
# [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
[[1,2,3] * 5]
# 返回值为
# [[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]]
[[1,2,3]] * 5
# 返回值为
# [[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]

3、裂变删除元素

1、remove

remove(value)-> None
# 删除找到第一个  value=> ValueError 输入值

​ 从左至右查找第一个匹配value的值，找到就能移除该元素，并返回None,否则ValueError

​ 就地修改

​ 效率不高，找不到抛异常

2、pop

pop([index])-> item
# 尾部弹出，删除最后一个并且输出最后一个 输入索引 index=>IndexError
# 弹出索引值 后边前移

​ 不指定索引index,就从列表尾部弹出一个元素

​ 指定索引index,就从索引处弹出一个元素，索引超界抛出IndexError

​ 尾部弹不会有效率问题，其他位置操作效率不高

3、clear

clear()->None
# 清除列表所有元素，剩下一个空列表

七、列表复制

1、copy

copy()->List
import copy
a = [0,[1,2],3]
b = copy.deepcopy(a)
# 输出 a，b
# ([0, [1, 2], 3], [0, [1, 2], 3])

2、shadow copy

​ 影子拷贝，也叫浅拷贝，遇到引用类型，只是复制了一个引用而已，引用原列表元素的地址，会随着原列表元素的改变而改变。

3、deep copy

​ 深拷贝，拷贝后，拥有了一个新的列表，完完全全的辅助，不会随着原列表元素改变而改变。一般不会随便使用。

八、列表其他操作

1、reverse

reverse() -> None
# 将列表元素反转，返回None
# 就地修改
l1 = []
l1.extend(range(1,5))
l1.reverse()
# 输出l1结果为
# [4, 3, 2, 1]

2、sort

sort(key=None,reverse=False)-> None
# 对列表元素进行排序，就地修改，默认升序
# reverse为Ture,反转，降序
lst.sort(key=function)

3、in

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

九、随机数

random模块

import random
l4 = [3, 2, 1]
random.choice(l4) # 选择随机一个数
random.shuffle(l4)  # shuffle 打乱，洗牌
random.randint(1,3) # [1,3] 特别注意！！！
random.randrange(1,3) # [1,3)
random.sample(l4,k=1) # 从一个列表里边抽 K个数值 从样本空间中抽 K个不同的元素
# 不同位置上的元素  值一样也是不同的元素，不能混为一谈

十、元组

1、定义

​ 一个有序的元素组成的集合

​ 使用小括号（）表示 （区别于列表的 [] ）

​ 元组是不可变对象

​

tuple() -> empty tuple
tuple(iterable)=>tuple initialized from iterable's items

2、元组元素的访问

支持索引，但不可超界

元组通过索引访问：

​ tuple[index],index就是索引，

3、元组查询

index(value,[start,[stop]]

通过value,从指定区间查找列表内的元素是否匹配

匹配第一个就立即返回索引

匹配不到，抛出异常ValueError

count(value)

返回列表中匹配value的次数

时间复杂度

index和count方法都是O（n）

随着列表数据规模的增大，而效率下降

len(tuple)

返回元素的个数

3、命名元组列表

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

命名元组，返回一个元组的子类，并定义了字段

fidle_names可以是空白符或逗号分隔的字段的字符串，可以是字段的列表

from collections import nameduple  #导入命名元组
Point = namedtuple('_Point',['x','y'])# Point为返回的类
p = Point(11,22)

十一、冒泡法（bubble sort)

1、定义

属于交换排序

两两比较大小，交换位置。如同水泡咕嘟咕嘟往上冒

结果分为升序和降序

2、方法

方法

nums = [6,5,4,]
length = len(nums)
for i in range(length - 1):
    for j in range(length-1-i):
        if nums[j]> nums[j+1]:
            temp = nums[j]
            nums[j] = nums[j+1]
            nums[j+1] = temp
print(nums)

优化后

nums = [9,8,7,6,5,4,3,2,1]
length = len(nums)
for i in range(length - 1):
    flag = False
    for j in range(length-1-i):
        if nums[j]> nums[j+1]:
            temp = nums[j]
            nums[j] = nums[j+1]
            nums[j+1] = temp
            flag = True
print(nums)

冒泡方法需要数据一轮轮比较

可以设定一个标记判断此轮是否有数据交换发生，如果没有发生转换，可以结束排序，如果发生转换，继续下一轮排序

最差的排序i情况是，初始顺序与目标顺序完全相反，遍历次数1，...,n-1直和n(n-1)/2

最好的排序情况是，初始顺序与目标顺序完全相同，遍历次数n-1

时间复杂度O(n*n)

十二、字符串

1、定义

一个个字符组成的有序的序列，是字符的集合

使用单引号，双引号、三引号引住的字符序列

字符串是不可变对象

pythin3起，字符串就是Unicode