1. python 的常用数据类型
1.1 数值型
python 的数值类型有int（整型）、float（浮点型）、complex（复数）bool（布尔型）。
以下是类型转换的函数：
int(x) 丢弃小数部分，只留下整数部分。
int(3.7)
3
float(x) 如果是整型转化为浮点型，就后面加个小数点。
float(5)
5.0
conplex(x) 或者complex(x,y) 前者括号里直接写数值，后者x代表实数部分，y代表虚数部分的系数。
bool(x)
# float(str) 和int(str) 时，如果str 由纯数字组成，那可以类型转换，如果不是，就会报错。
# 复数，a+b*i 的形式，a 是这个复数的实部，b*i 是这个复数的虚部，i 代表-1的平方根。
# float 是双精度类型值。
# 双精度：在机内占用八个字节，64位的二进制数字，转换成十进制，大概有15~16位数字。（单精度占4个字节）
# 复数无法转化为整数和浮点数
type() 确定一个值得类型‘
# 返回的是一直类型，str，float，int，complex等，返回的不是字符串。
isinstance(object,class_or_tuple) 确认一个值是不是某个类型的，返回的是bool值
num = input('>>>')
while not instance(num,(int,float)):
num = input('Again:')
...
# 可以规定用户输入的类型
1.2 序列对象
tuple（元组）
str（字符串）
list（列表）
1.3 键值对
dic（字典）
set（集合）
2. 有关数据的一些函数
2.1 math模块
python中的模块使用之前，需要输入：
import module
# 不加冒号：，用之前要加上模块.做前缀
math.floor() 无论小数部分是多少，都向下取整。
math.floor(3.7)
3
math.ceil() 和上面相反，向上取整。
math.ceil(3.1)
4
math.sqrt() 把括号内的值开方，返回的值是浮点数。所以，无法给复数开方，原因就是复数无法转换成浮点数。
math.sqrt(4)
2.0
math.pi 就是返回圆周率，π 的值。
math.e 返回自然常数，e 的值。
2.2 一些数字处理函数
max() 取括号内数值的最大值，里面可以是很多元素，也可以是一个可迭代对象。只能比浮点数和整数。
min() 取括号内最小的值，规则和上面一样。
pow(x,y) 相当于x**y ，做平方时候挺有用的。
round() 有个很牛逼的规则，“四舍六入五取偶”，就是，小数部分超过0.5，往上取值，低于0.5，往下取值，如果等于0.5，就往与数值最近的偶数靠。
round(3.5),round(4.5)
4,4
round(5.4),round(5.6)
5,6
3. 列表list
3.1 列表的定义
3.1.1 列表 list
一个排列整齐的队伍，由若干元素组成，元素可以是任意对象。
列表内元素有顺序（sequence），这样才能用索引。
用[ ]表示。
列表在内存中，也要求是连续的，线性的数据结构。
列表是可变的。
列表内的元素，索引查找非常快，但是增加或者删除效率很低（内存地址是连续的优点和缺点）。
3.1.2 链表 linked list
链表在内存中，不要求连续，是散落的。但是有顺序，上一个元素知道下一个元素在哪。一个片夜空中有很多散落的星星，用笔把星星依次连接起来。
链表在内存里的结构是：DATA+NEXT。DATA是当前索引号对应的数据，NEXT是下一个索引号的内存地址。
索引查找很慢，但是增加和删除的效率很高（但也只是相对于列表来说），但是要插在具体某个顺序，还是要先数一遍（内存地址不连续的优缺点）。
3.1.3 队列 queue（和列表list比较像）
也是需要内存中的一片连续的空间。
先进先出的队列，一般队列不是用来增加或删除元素的。
也不是用来遍历的，就是大家排个队，一个一个走。最先进入queue的最先使用。
给我的感觉是，一个没办法取出某个索引号数据的列表，只能按顺序使用。
3.1.4 栈 stack
后进先出队列，类似于落盘子，最后进入stack的最先使用（就是翻过来的queue）。
3.2 列表的赋值
# python里，赋值既定义。
定义空列表
lst = []
lst = list()
定义非空列表
# 直接往里面填元素。可迭代对象，值什么的都可以作为元素写进去。
lst = [1,2,range(6),[2,3,4],'abc']
# 直接往里面填元素，里面有一个可迭代对象，只有一个元素。
lst = [range(5)]
lst
[range(5)]
把可迭代对象转化成列表
# 一定要用list(iteratable)，并且只能写一个iteratable 。
lst = list(range(5))
lst
[0,1,2,3,4]
# 列表不能一开始就定义大小。
3.3 列表的索引
索引，也叫下标。
正索引，从左至右，从0 开始，为列表中每一个元素的编号。
负索引，从右至左，从-1开始，为倒数第一个元素的索引号，-2位倒数第二个元素的索引号。
索引不可以超界，会报错，index error。
3.3.1 lst[index]
# 这个lst是要索引元素的列表的标识符，我这就用lst代表了。
查找索引号对应的值
lst = [1,2,3,4,5,5,6,7]
lst[3]
4
# 也可以对某个索引号的元素赋值
lst[0] = 99
lst
[99,2,3,4,5,5,6,7]
# 这种赋值时，索引号必须存在，不然报错，indexerror。这个操作是把列表中某一个索引号的值修改一下，时间复杂度为O(1)，一步到位，效率最高。（时间复杂度下面有写）
3.3.2 lst.index(value[,start[,stop]])
按照索引号规定一个界限，查找界限内的，符合值得索引号是多少。
lst.index(5,0,4)
4
# 注意从左至右查过，如果能找到，查找到第一个就结束，返回索引号。如果后面还有相同的值，不返回；如果找不到，抛异常。
lst.index(5)
4
# 索引号为5 的没有显示。
3.3.3 lst.count(value)
计算列表中某一个值得元素的个数
lst.count(5)
2
3.3.4 时间复杂度
计算机科学中，算法的时间复杂度是一个函数，它定性描述了该算法的运行时间。
这是一个关于代表算法输入值的字符串的长度的函数。（？？？）
时间复杂度常用大O符号表述，不包括这个函数的低阶项和首项系数（？？？）。使用这种方式时，时间复杂度可被称为是渐近的，它考察当输入值大小趋近无穷时的情况。
index 和count 方法都是O(n)，就是有多少元素，多大。所以index和count的效率特别慢。
随着列表数据规模增大，而效率下降。
3.3.5 len()
可以返回列表的长度，从前到后数一遍，时间复杂度O(n)。
整型和浮点型的值，没有长度，不能用len()。
计算列表长度是，计算的是列表内元素个数，也就是说，如果一个元素是可迭代对象，或者其他类型的值，如[1，2，3]，那么长度只增加1，而不是增加3.
计算列表长度时，没必要每次都数一遍。第一次数一遍，然后设置一个计数器count，有1个元素进来，count就+1，删除2个元素，count就-2，最后列表长度用count表示。
3.4 列表增加、插入元素
3.4.1 lst.append(object)
在列表尾部追加一个元素，返回None，就是不返回任何东西，不是创造一个新列表，是在原有列表的基础上修改，就叫做就地修改。
时间复杂度就是O(1)。
lst.append(8)
lst
[99,2,3,4,5,5,6,7,8]
# 注意，如果用append，增添一个可迭代对象，只相当于在列表最后添加一个元素。
lst.append([9,10])
lst
[99,2,3,4,5,5,6,7,8,[9,10]]
3.4.2 lst.insert(index,object)
在指定的索引位置插入元素，属于就地修改。
lst.insert(0,98)
lst
[98,99,2,3,4,5,5,6,7,8,[9,10]]
# 注意，插入是占用目标索引号的位置，然后后面的元素索引号和内存地址一次往后挪，前面的元素不变。
时间复杂度O(n)，列表插入元素之后，还要挪动元素的位置
如果index超过列表索引上界，在列表的最后追加；超过下界，在列表的开头追加。
insert这个函数要少用，用了效率会很低
3.4.3 lst.extend(iteratable)
将可迭代对象的元素追加进来，加到尾部，返回None，就地修改。
lst2 = [1,2,3]
# 重新定义一个列表，lst已经太长了,赋值粘贴我都懒得粘
lst2.extend(range(4,7))
lst2
[1,2,3,4,5,6]
3.4.4 +
拼接操作，返回一个新的列表
lst3 = [1,2]
lst4 = [3,4]
a = lst3 + lst4
b = lst4 + lst3
a
[1,2,3,4]
b
[3,4,1,2]
# 注意这个拼接是有顺序的,按照+前后的顺序拼接起来
因为不是就地修改，会创建一个新的列表，所以这样也会使内存空间使用翻倍。
3.4.5 *
把列表内的元素重复几遍，返回一个新列表。
lst5 = [1,[2,3]]
lst5 * 3
[1,[2,3],1,[2,3],1,[2,3]]