# 数据结构分类：
数值型：
int、float、complex、bool
序列对象：
字符串：str
列表：list
tuple：
键值对：
集合：set
字典：dict
## 分类详解：
数值型：
1、int、float、complex、bool都是class
2、int：python3的int就是长整型，且没有大小限制，受限于内存区域的大小
3、float：有整数部分和小数部分组成。支持十进制和科学计数法表示。只有双精度型。
4、complex：有实数和虚数部分组成，实数和虚数部分都是浮点数，3+4.2j
5、bool：int的子类，仅有两个实例True、False对应1和0，可以和整数直接运算
类型转换(built-in):
int(x)：返回一个整数
float(x)：返回一个浮点数
complex(x)、complex(x,y)：返回一个复数
bool(x)：返回布尔值，False=0，True=1
## 数字的处理函数：
1、round()：四舍五入，四舍六入五取偶
model：
round(4.6) 5
round(3.5) 4
round(4.5) 4
2、floor()地板、ceil()天花板
即一个向下取，一个向上取
model：
import math
math.ceil(2.5)
>>>3
math.floor(2.5)
>>>2
3、int()：取整数部分，和//整除一样
model：
int(2.9)
>>>2
4、min():
取出最小的值
model:
min(1,8,2,0)
>>>0
5、max()：
取出最大值
max(1,8,2,0)
>>>8
6、pow(x,y)等于x**y：
pow(x,y)：返回的是x的y次方，如果是pow(x,y[,z]),其效果就等于x**Y % z
注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为float
pow(2,4)
>>>16
pow(2,4,3)
>>>1
pow(2,4,4)
>>>0
7、math.sqrt()：
sqrt():返回数字的平方根
math.sqrt(16)
>>>4.0
8、进制函数
1、bin():二进制
2、oct()：八进制
3、hex()：十六进制
9、math.pi ：
数学常量 pi（圆周率，一般以π来表示）
math.pi
>>>3.141592653589793
10、math.e：
自如常数
math.e
>>>2.718281828459045
## 类型判断：
1、type(obj)，返回类型，而不是字符串
type(1)
>>>int
type(1+True)
>>>int
type(1+True+2.0)
>>>float
2、isinstance(obj,class_or_tuple)
model：
isinstance(‘a’,str)
>>>True
isinstance(6,(str,bool,int))
>>>True
# 列表list
1、一个队列，一个排列整齐的队伍
2、列表内的个体称作元素，有若干个元素组成列表
3、元素可以是任意对象(数字、字符串、对象、列表等)
4、列表内元素有顺序，可以使用索引
5、线性的数据结构
6、使用[]表示
7、列表是可变的
8、列表list、链表、queue、stack(栈)的差异
a、链表：链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
b、queue：队列是一种特殊的线性表，是一种先进先出（FIFO）的数据结构。它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。
c、stack：栈（stack）在计算机科学中是限定仅在表尾进行插入或删除操作的线性表。
列表list定义 初始化
list()->new empty list
list(iterable)->new list initialized from iterable’s iterms
列表不能一开始就定义大小
l1 = list()
l1 = []
l1 = [2,6,9,’ab’]
l1 = list(range(5))
列表索引访问：
1、索引也叫下标
2、正索引：从左至右，从0开始，为列表中每一个元素编号
l1
>>>[4, 7, 2, 1, 5, 9]
l1[0]
>>>4
l1[1]
>>>7
3、负索引：从右至左，从-1开始
l1[-1]
>>>9
l1[-2]
>>>5
4、正负索引不可以超界，否则引发异常IndexError
l1[6]
IndexError: list index out of range
5、为了理解方便，可以认为列表是从左至右排列的，左边是头部，右边是尾部，左边是下界，右边是上界
6、列表通过索引访问
a、list[index],index就是索引，使用中括号访问
# 列表查询
1、index(value,[start,[stop]])
a、通过值value，从指定区间查找列表内的元素是否匹配
l1
>>>[4, 7, 2, 1, 5, 9, 7, 7, 3, 7]
l1.index(7,2,7)
>>>6
b、匹配第一个就立即返回索引
c、匹配不到，抛出异常ValueError
l1.index(7,2,6)
>>>ValueError: 7 is not in list
2、count(value)
返回列表中匹配value的次数
l1.count(7)
>>>4
3、时间复杂度
a、index和count方法都是O(n)
b、随着列表数据规模的增大，而效率下降
4、len()：返回元素的个数
len(l1)
>>>10
# 列表元素修改
索引访问修改：
1、list[index] = value
l1
>>>[4, 7, 2, 1, 5, 9, 7, 7, 3, 7]
l1[1]=0
>>>[4, 0, 2, 1, 5, 9, 7, 7, 3, 7]
2、索引不要超界
# 列表增加、插入元素
append(object)->None
1、列表尾部追加元素，返回None
l1.append(100)
l1
>>>[4, 0, 2, 1, 5, 9, 7, 7, 3, 7, 100]
lst.append(9)
lst
>>>[1, 2, 3, 2, 2, 5, 2, 9]
a = lst.append(10)
type(a)
NoneType
print(a)
返回None
2、返回None就意味着没有新的列表产生，就地修改
3、时间复杂度是O(1)
insert(index，object)->None
1、在指定的索引index处插入元素object
2、返回None就意味着没有新的列表产生，就地修改
3、时间复杂度是O(1)
4、索引能超上下界吗？
超越上界，尾部追加
超越下界，头部追加
extend(iteratable)->None
1、将可迭代对象的元素追加进来，返回None
2、就地修改
+->list
1、连接操作，将两个列表连接起来
l1
>>>[4, 0, 2, 1, 5, 9, 7, 7, 3, 7, 100]
l2
>>>[10, 11, 18, 14]
l3
>>>[4, 0, 2, 1, 5, 9, 7, 7, 3, 7, 100, 10, 11, 18, 14]
2、产生新的列表，原列表不变
l1
>>>[4, 0, 2, 1, 5, 9, 7, 7, 3, 7, 100]
l2
>>>[10, 11, 18, 14]
3、本质上调用的是__add__()方法
*->list
1、重复操作，将本列表元素重复n次，返回新的列表
l4 = 2*l2
l4
[10, 11, 18, 14, 10, 11, 18, 14]
# 列表删除元素
remove(value)->None
1、从左至右查找第一个匹配value的值，移除该元素，返回None
l4.remove(11)
l4
[10, 18, 14, 10, 11, 18, 14]
2、就地修改
3、效率？
pop([index])->item
1、不指定索引index，就从列表尾部弹出一个元素
l4.pop()
>>>14
l4
[10, 18, 14, 10, 11, 18]
2、指定索引index，就从索引处弹出一个元素，索引超界抛出IndexError错误
3、效率？指定索引的时间复杂度？不指定索引呢？
clear()->None
清除列表所有元素，剩下一个空列表
l3.clear()
l3
>>>[]
# 列表其它操作
reversed()->None
1、将列表元素反转，返回None
l1
>>>[4, 0, 2, 1, 5, 9, 7, 7, 3, 7, 100]
l1.reverse()
l1
>>>[100, 7, 3, 7, 7, 9, 5, 1, 2, 0, 4]
2、就地修改
sort(key=None,reverse=False)->None
1、对列表元素进行排序，就地修改，默认升序
l1.sort()
l1
>>>[0, 1, 2, 3, 4, 5, 7, 7, 7, 9, 100]
2、reverse为True，反转，降序
l1.sort(reverse=True)
l1
>>>[100, 9, 7, 7, 7, 5, 4, 3, 2, 1, 0]
3、key是一个函数，指定key如何排序
lst.sort=(key=functionname)
in：
[3,4]in [1,2,[3,4]]
for x in [1,2,3,4]
lst0 = list(range(4))
id(lst0)
hash(id(lst0))
lst1 = list(range(4))
id(lst1)
lst0 == lst1 取值比较,内容
True
lst0 is lst1 取id，就是内存地址比较
False
lst1 = lst2
lst2[2] =10
lst0 = [1,[2,3,4],5]
lst5 = lst0.copy()
lst0[1][1]= 20
那么lst0 == lst5为True，因为里面拷贝的为内存 地址
列表复制：
1、copy()->List
l1
>>>[100, 9, 7]
l2 = l1.copy()
l2
>>>[100, 9, 7]
l1 == l2
True
shadow copy返回一个新的列表
2、shadow copy
影子拷贝，也叫浅拷贝，遇到引用类型，只是复制了一个引用而已
3、深拷贝
copy模块提供了deepcopy
# 随机数
1、random模块
random.choice([1,2,3,4,5])
random.randint(0,1)
2、randint(a,b)返回[a,b]之间的整数
3、choice(seq)从非空序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。random.choice([1,3,5,7])
4、randrange([start,]stop[,step])从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1.random.randrange(1,7,2)
5、random.shuffle(list)->None就地打乱列表元素
# 时间复杂度：
index和count方法都是O(n)
效率最高的是O(1)1表示为常数
最低的是O(n**2)
pass占位语句
tuple：
一个有序的序列，不可变
可以重复元素
所谓无序就是定义的顺序和打印的顺序不一样,但是可以遍历
可迭代对象构建：t=tuple(range(1,7,2))
t1= (1,)
转义：两个同符号或者\
0920练习：
元组tuple：
1、一个有序的元素组成的集合
2、使用小括号()表示
3、不可变对象
定义：
t = tuple()–空元组
t=()
“`
In [22]: t=tuple(range(1,9,2))
In [23]: t
Out[23]: (1, 3, 5, 7)
“`
In [24]: t = (2,4,6,1,7,9)
In [25]: t[1]
Out[25]: 4
单个元素的元组的定义：
t = (1,)
In [30]: type(t)
Out[30]: tuple
下面的做法是错误的：
In [27]: t = (1)
In [28]: type(t)
Out[28]: int
乘法的使用：
In [31]: t1 = t*5
In [32]: t1
Out[32]: (1, 1, 1, 1, 1)
访问：支持索引
In [35]: t1 = (1,2,6,8,0)
In [36]: t1[1]
Out[36]: 2
In [37]: t[-1]
Out[37]: 1
一旦定义，不可以修改，否则，就生成新的列表
tuple.index(value,[start,[stop]])
生成新的元组，可以使用：
In [44]: t = tuple(range(1,9,3))
In [45]: t
Out[45]: (1, 4, 7)
注：一定要使用tuple(range(x))，否则无法创建成功
In [47]: t.index(4,1,3)
Out[47]: 1
如果使用t.index(4,2,3),就会报议程错误，因为匹配不到
匹配次数：
In [48]: t.count(4)
Out[48]: 1
元组中元素的个数：
In [49]: len(t)
Out[49]: 3
# 因为元组是不可变的，所以不支持增删改
命名元组：
form collections import namedtuple
In [50]: from collections import namedtuple
In [51]: Point = namedtuple(‘_Point’,[‘x’,’y’])
In [52]: p = Point(89,24)
In [53]: p.x
Out[53]: 89
In [54]: p.y
Out[54]: 24
In [55]: Student = namedtuple(‘Student’,’name age’)
In [56]: tom = Student(‘tom’,20)
In [57]: jerry = Student(‘jerry’,18)
In [58]: tom.name
Out[58]: ‘tom’
In [59]: tom.age
Out[59]: 20
冒泡排序：
num_list = [1,2,3,4,5,6,7,9,8]
length = len(num_list)
count_swap = 0
count = 0
for i in range(length):
flag = False
for j in range(length-i-1):
count += 1
if num_list[j] > num_list[j+1]:
tmp = num_list[j]
num_list[j] = num_list[j+1]
num_list[j+1] = tmp
flag = True
count_swap += 1
if not flag:
break
print(num_list,count_swap,count)
字符串：
1、一个个字符组成的有序的序列，是字符的集合
2、使用单引号、双引号、三引号引住的字符序列
3、字符串是不可变对象
In [60]: s1 = ‘abc’
In [61]: s2 = “telephone”
In [62]: s3 = ”’My telephone number is “13938495980””’
In [67]: s1
Out[67]: ‘abc’
In [68]: s2
Out[68]: ‘telephone’
In [69]: s3
Out[69]: ‘My telephone number is “13938495980”‘
In [63]: s4 = ‘My name \n is Eric’
In [64]: s4
Out[64]: ‘My name \n is Eric’
In [70]: s5 = r”My name \n is Eric”
In [71]: s5
Out[71]: ‘My name \\n is Eric’
In [72]: s6 = ‘c:\windows\nt’
In [73]: s6
Out[73]: ‘c:\\windows\nt’
In [74]: s6 = R”c:\windows\nt”
In [75]: s6
Out[75]: ‘c:\\windows\\nt’
In [76]: s8 = ‘c:\windows\\nt’
In [77]: s8
Out[77]: ‘c:\\windows\\nt’
In [78]: sql = “””select * from user where name=’root'”””
In [79]: sql
Out[79]: “select * from user where name=’root'”
In [80]: sql[4]
Out[80]: ‘c’
In [82]: for c in sql:
…: print(c)
…: print(type(c))
…:
s
<class ‘str’>
e
<class ‘str’>
……
可以迭代：
lst = list(sql)
星号标记课件：
“string”.join(iterable)->str
1、使可迭代的对象连接起来，使用string作为分隔符
2、可迭代对象本身元素都是字符串
3、返回一个新字符串
In [84]: lst = [‘6′,’8′,’3’]
In [85]: print(“\””.join(lst)) 分隔符是双引号，\是转义
6″8″3
In [86]: print(” “.join(lst))
6 8 3 空格作为分隔符
In [87]: print(“\n”.join(lst))
6
8
3 换行符作为分隔符
In [88]: lst = [‘1’,[‘x’,’y’],’3′]
In [89]: print(” “.join(lst))
—————————————————————————
TypeError Traceback (most recent call last)
<ipython-input-89-6106afe592ed> in <module>()
—-> 1 print(” “.join(lst))
TypeError: sequence item 1: expected str instance, list found
抛出异常，typeError
字符串+连接：
+ ->str
1、将连个字符串连接在一起
2、返回一个新字符串
字符串分割：
1、split系：
将字符串按照分隔符分割成若干个字符串，并返回列表
2、partition系：
将字符串按照分隔符分割成2段，返回这2段和分隔符的元组
# split
split(sep=None,maxsplit=-1)-> list of strings
1、从左至右
2、sep指定分割字符串，缺省的情况下空白字符串作为分隔符
3、maxsplit指定分割的次数，-1表示遍历整个字符串
In [1]: s1 = “I’m \ta super man.”
In [2]: s1.split()
Out[2]: [“I’m”, ‘a’, ‘super’, ‘man.’]
字符串分割：
一、split系：
将字符串按照分隔符分割成若干个字符串，并返回列表
二、partition系：
将字符串按照分隔符分割成2段，返回这2段和分隔符的元组
1、split
split(sep=None,maxsplit=-1) -> list for strings
- 从左至右
- sep指定分割字符串，缺省的情况下空白作为分割符
- maxsplit指定分割的次数，-1表示遍历整个字符串
model：
In [1]: s1 = “I’m \ta super man.”
In [2]: s1.split()
Out[2]: [“I’m”, ‘a’, ‘super’, ‘man.’]
In [3]: s1.split(‘s’)
Out[3]: [“I’m \ta “, ‘uper man.’]
2、rspilt
rsplit(sep=None,maxsplit=-1) -> list of strings
- 从右向左
- sep指定分割字符串，缺省的情况下空白字符串作为分隔符
- maxsplit指定分割次数，-1表示遍历整个字符串
3、splitlines
splitlines([keepends])->list of strings
- 按照行来切分字符串
- keepends指的是是否保留行分隔符
- 行分隔符包括\n,\r\n,\r等
二：partition
1、 partition(sep)->(head,sep,tail)
- 从左至右，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组；如果没有找到分隔符，就返回头、2个空元素的三元组。
- sep分割字符串，必须指定
- rpartition(sep)->(head,sep,tail)
- 从右至左，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组；如果没有找到分隔符，就返回2个空元素和尾的三元组
三、字符串大小写
1、upper()：全大写
2、lower()：全小写
3、大小写，做判断时候用
4、swapcase()：交互大小写
四、字符串排版
1、title() -> str
标题的每个单词都大写
2、capitalize()-> str
首个单词大写
3、center(width[,fillchar]) -> str
width 打印宽度
fillchar 填充的字符
4、zfill(width)->str
width 打印宽度，局右，左边用0填充
5、ljust(width[,fillchar])-str：左对齐
6、rjust(width[,fillchar])->str：右对齐
五、字符串修改
1、replace(old,new[,count])->str
字符串中找到匹配替换为新子串，返回新字符串
count表示替换几次，不指定就是全部替换
2、strip([chars])->str
从字符串两端去除指定的字符集chars中的所有字符
如果chars没有指定，去除两端的空白字符
lstrip([chars])->str：从左开始
rstrip([chars])-str：从右开始
六、字符串查找
1、find(sub[,start[,end]])->int
在指定的区间[start,end)，从左至右，查找子串sub。找到返回索引，没有找到返回-1
2、rfind(sub[,start[,end]])
在指定的区间[start,end),从右至左，查找子串sub。找到返回索引，没有找到返回-1
3、index(sub[,start[,end]])->int
在指定的区间[start,end],从左至右，查找字符串sub。找到返回索引，没有找到抛出异常ValueError
4、rindex(sub[,start[,end]]) ->int
在指定的区间[start,end]，从左至右，查找子串sub。找到返回索引，没有找到抛出异常ValueError。
七、时间复杂度
index和count方法都是O(n)
随着列表数据规模的增大，而效率下降
1、len(string)
返回字符串的长度，即字符的个数
2、count(sub[,start[,end]])->int
在指定的区间[start,end],从左至右，统计子串sub出现的次数。
八、字符串判断
1、endswith(suffix[,start[,end]])->bool
在指定的区间[start,end]，字符串是否是suffix结尾
2、startwith(prefix[,start[,end]])->bool
在指定的区间[start,edn]，字符串是否是prefix开头
3、is系列
isalnum()->bool：是否是字母和数字组成
isalpha()：是否是字母
isdecimal()：是否只包含十进制数字
isdigit()：是否全部是数字
isidentifier()：是不是字母和下划线开头，其他都是字母、数字、下划线
islower()：是否都是小写
isupper()：是否全部为大写
isspace()：是否只包含空白字符
九、字符串格式化
字符串的格式化是一种拼接字符串输出样式的手段，更灵活方便
join拼接只能使用分隔符，切被拼接的是可迭代
+拼接字符串还方便，但非字符串需要先转换为字符串才可以
format：
格式语法：
format函数格式字符串语法—Python鼓励使用
1、”{}{xxx}”.format(*args,**kwargs)–>str
2、args是位置参数，是一个元组
3、kwargs是关键字参数，是一个字典
4、花括号表示占位符
5、{}表示按照顺序匹配位置参数，{n}表示取位置参数索引为n的值
6、{xxx}表示关键字参数中搜索名称一致的
7、{{}}表示打印花括号
a、位置参数：
“{}:{}”.format(‘192.168.1.100’,8888)，这就是按照位置参数顺序用位置参数替换前面的格式字符串的占位符
b、关键字参数或命名参数
“{server}{1}:{0}”.format(8888,’192.168.0.200’,server=’Web Server Info:’位置参数按照序号匹配，关键字参数按照名词匹配
c、访问元素
“{0[0]}.{0[1]}”.format((‘Eric’,’com’))
d、对象属性访问
from collections import namedtuple
Point = namedtuple(‘Point’,’x y’)
p = Point(4,5)
“{{{0.x},{0.y}}}”.format(p)
对齐：
‘{0}*{1}={2:<2}’.format(3,2,2*3) ‘{0}*{1}={2:<02}’.format(3,2,2*3) ‘{0}*{1}={2:>02}’.format(3,2,2*3) ‘{:^30}’.format(‘centered’)
‘{:*^30}’.format(‘centered’)
进制：
“int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}”.format(42)
“int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}”.format(42)
octets = [192, 168, 0, 1] ‘{:02X}{:02X}{:02X}{:02X}’.format(*octets)
本文来自投稿，不代表Linux运维部落立场，如若转载，请注明出处：http://www.178linux.com/87484
