数据结构和运算

Python的数据类型及其运算

数据类型

• 不可变数据类型：

  • number（数字型）：int、bool、float、complex（复数型）

  • str（字符串型）

  • tuple（元组型）

• 可变：

  • list（列表型）

  • set（集合型）

  • dictionary（字典型）

  • int 整数型：

  • bool 逻辑型：

  • 实数型：

    • 科学计数法：123e3或123E3，e或E之前必须有数字，后面的指数必须是整数

  • 复数型：3+4J，5+6j

字符串型：

转义字符：\b    backspace     BS 退格

      \t    horizontal tab    HT Tab键

      \n    linefeed        LF 换行

      \f    form feed    FF 换页

      \r    carriage return     CR 回车

      \"    double quote    双引号

      \'    single quote    单引号

      \\    backslash        反斜杠

      \            续行符

元组型：（）和list列表类似，但元素不能修改

列表型：[]

集合型：{}，不能包好列表型、集合型、字典型。

字典型：

可变类型的数据：同一值赋值给不同变量或同一值多次赋值给同一变量，id值不同

不可变类型的数据：同一值赋值给不同变量，id相同；给变量的赋值发生变化，id改变

数据类型转换

int(x,[,base])		x转为整数

float(x)			x转为浮点数

complex(real[,imag])	创建一个复数

str(x)			将对象x转换为字符串

repr(x)			将对象x转换为表达式字符串

eval(str)			计算在字符串中有效Python表达式，返回一个对象

tuple(s)			将序列s转换为元组

list(s)			将序列s转换为列表

set(s)			转换为不可变集合

dict(d)			创建一个字典，d必须是一个序列(key,value)元组

frozenset(s)		转换为不可变集合

chr(x)			将x转换为字符

ord(x)			将x转换为它的整数值

hex(x)			将x转换为十六进制字符串

oct(x) 			将转换为八进制字符串

运算

算术运算符和算术表达式

+	加法。

-

*	两个数相乘或是一个被重复若干次的字符串 "hello"*2结果为"hellohello"

/

%

**	b**a为b的a次方

//	返回商的整数部分（向下取整）35//15=2      -35//15=-3

注：1、+   列表、元组、字符串的连接

    2、*   列表、元组、字符串三种有序序列与整数相乘，表示将序列赋值整数倍

关系运算符和关系表达式

> >= < <= == !=

注：
Python关系运算符可以连用。具有惰性求值或者逻辑短路的特点，即从左向右运算中，有部分结果为False，终止运算

实数型数据之间比较是否相等是，不宜使用“x==y”，而应使用两个数之差的绝对值小于一个很小的数的形式判断

---

逻辑运算符和逻辑表达式

and or not

注：Python逻辑运算符具有惰性求值或者逻辑短路的特点。

---

赋值运算符和赋值表达式

---

位运算符

与&	op1 & op2 

位或|	op1 | op2

位非~	~op1

位异或^	op1 ^ op2

左移<<	op1<<op2	op1左移op2位

右移>>	op1>>op2	op1右移op2位

---

成员运算符

in

not in

身份运算符

is	判断是否引用自一个对象

not is

---

运算符优先级

(),[]

x.attrbute（属性访问）

**

~

+,-（符号运算符）

*,/,%,//

+,-（加减法）

>>,<<

&

^

|

==,!=,<=,<,>,>=

=,%=,/=,//=,-=,+=,*=,**=

is,is not

in,not in

not

and

or

lambda

---

条件控制语句

if-else语句

if 表达式:

      语句块1

else:

      语句块2

if-elif-else语句

---

循环语句

while循环

while 表达式:

    语句块while    # 后面else这部分一般不加
else:                   
    语句块else

for循环

for 变量 in 序列:
	
    语句块for   # 后面else这部分一般不加
else:       

	语句块else

说明：

range()函数可以生成数列，因此可以和for循环配套使用。

range()函数的格式为：range(start,end[,step])  

生成一个初值为start，截止值为end，步长为step的数列，step省略是步长默认为1

for i in range(5)  范围[0,5) 运行5次，从0开始
while也可以搭配else

跳转语句

break语句

continue语句

return语句

---

数据结构

字符串String

记为  s = ''   或	s = ""

Python没有字符类型，可以用单字符串代替

字符串连接：+

重复输出字符串：*运算

s2 = s1 * n	将s1复制n次给s2

成员运算符：in运算

s2 in s1  判断s2是不是s1的子串，是为True，否为False

索引号规则

Python中，n个元素构成的有序序列（字符串、列表等）的索引号从左到右依次为0,1,2,……，n-1

从右到左依次为-1，-2，……，-n

正序列号 = 负索引号 + len（序列）

切片 截取有序序列的部分或全部元素

形式1：序列[index]		截取序列号为index的元素

形式2：序列[start：end]

    从左向右截取索引号start至索引号end之间的元素，但不包括end，省略start时默认为从最左边开始截取，省略end时截取到最右边。start和end为正负均可，一般要求start位于end左边，否则截取为空

形式3：序列[start: end: step]

    step>0时，从左向右截取start至end之间的元素，但不包括end，省略start默认从最左边开始，省略

end默认截取到最右边，start和end正负均可，一般要求start位于end左边，否则截取为空

    step<0时，从右向左截取start至end之间的元素，不包括end，省略start默认从最左边开始，省略

    end默认截取到最右边，start和end正负均可，一般要求start位于end右边，否则截取为空

字符串格式化

（1）%格式符方法	        %[(name)][flags][width].[precision]typecode

（2）format方式	        [[fill]align][sign][#][0][width][,][.precision][type]

字符串常见函数及方法

s.zfill(n) ： 字符串前面补0，n为设置字符串长度

1、去掉空格和特殊符号

s.strip()：去掉空格和换行符

s.strip('xx')：去掉某个字符串

s.lstrip()：去掉左边的控分和换行符

s.rstrip()：去掉右边的空格和换行符

2、字符串的搜索和替换

s.count('x')：查找某个字符在字符串里面出现的次数

s.capitalize()：首字母大写

s.center(n,'-')：把字符串放中间，两边用-对齐

s.find('x')：找到这个字符返回下标，多个时返回第一个；不存在的字符返回-1

s.index('x')：找到这个字符返回下标，多个时返回第一个；不存在的字符报错

s.replace(oldstr,newstr)字符串替换

s.format()：字符串格式化

3、字符串的测试和替换函数

s.startswith(prefix[,start[,end]])：是否以prefix开头

s.endswith(suffix[,start[,end]])：以suffix结尾

s.isalnum()：是否全是字母和数字，并至少有一个字符

s.isalpha()：是否全是字母，并至少有一个字符

s.isdigit()：是否全是数字，并至少有一个字符

s.isspace()：是否全是空白字符，并至少有一个字符

s.islower()：s中的字母是否全是小写

s.isupper()：s中的字母是否全是大写

s.istitle()：s是否是首字母大写的

4、字符串分割

s.split()：默认是按照空格分割

s.split(splitter)：按照splitter分割

5、字符串连接

joiner.join(slit)：使用连接字符串joiner将slit中的元素连接成一个字符串，slit可以是字符串列表、字典（可迭代的对象）。

int类型不能被连接

6、截取字符串（切片）

s='0123456789'

print(s[0:3])：截取第一位到第三位的字符

print(s[:])：截取字符串的全部字符

print(s[6:])：截取第七个字符到结尾

print(s[:-3])：截取从头开始到倒数第三个字符之前

print(s[2])：截取第三个字符

print(s[-1])：截取倒数第一个字符

print(s[::-1])：创造一个与原字符串顺序相反的字符串

print(s[-3:-1])：截取倒数第三位与倒数第一位之前的字符

print(s[-3:])：截取倒数第三位到结尾

print(s[:-5:-3])：逆序截取

string模块

import string

string.ascii_uppercase：所有大写字母

string.ascii_lowercase：所有小写字母

string.ascii_letters：所有字母

string.digits：所有数字

列表List []

列表创建：赋值创建，或调用函数list()由字符串、元素、集合、字典等创建。列表可为空[]

列表截取：与字符串类似，索引号，从左向右依次为：0,1,2,...从右向左依次为：-1,-2,-3,...

列表运算（和字符串类似）：

连接+，复制*，修改，判断某元素是否属于列表in，个数len()，最大值max()，最小值min()

列表相关操作示例：

• insert(i, e) 在第i个位置插入元素e
• remove(e) 删除元素e
• append(e) 追加元素e
• sort() 排序
• reverse() 逆转列表
• pop() 弹出尾元素

lst = []
n = int(input())
while n > 0:
    s = input()
    tmp = s.split()
    if tmp[0] == 'insert':
        lst.insert(int(tmp[1]), int(tmp[2]))
    elif tmp[0] == 'print':
        print(lst)
    elif tmp[0] == 'remove':
        lst.remove(int(tmp[1]))
    elif tmp[0] == 'append':
        lst.append(int(tmp[1]))
    elif tmp[0] == 'sort':
        lst.sort()
    elif tmp[0] == 'reverse':
        lst.reverse()
    elif tmp[0] == 'pop':
        lst.pop()
    n -= 1

输入：
12
insert 0 5
insert 1 10
insert 0 6
print
remove 6
append 9
append 1
sort
print
pop
reverse
print
输出：
[6, 5, 10]
[1, 5, 9, 10]
[9, 5, 1]

---

元组Tuple ()

元组创建：赋值创建，或调用函数tuple()由列表、集合、字符串等创建。元组可为空()，可只有一个元素

元素(10,)，只有一个元素时，逗号不能少，否则会认为是数学上的(5)。

元组截取：与字符串类似，索引号，从左向右依次为：0,1,2,...从右向左依次为：-1,-2,-3,...

元组运算：连接+，复制*，判断某元素是否属于元组in，个数len()，最大值max()，最小值min()

---

集合Set {}

集合创建：赋值创建，或调用函数set()由列表、元组、字符串等创建。空集合不能通过set1={}形式创建，只能通过set1=set()创建，set1={}是空字典。

集合添加和删除：s.add()添加元素，s.pop()随机删除一个元素，s.remove()和s.discard()删除指定元素

s.remove在删除元素不存在时会报错(KeyError)，s.discard()在删除元素不在时不会报错

---

字典Dictionary {}

无序的键(key):值(value)	通过键(key)存取，不是索引存取	

键key必须使用不可变类型，键key的类型可以不同，键值不能相同

值value的类型任意

创建字典：赋值创建，或创建空字典再逐一添加元素

访问字典里的值：字典对象[key]

修改字典：增加、修改、删除键/值对

删除字典：del命令可删除单一的元素，可清空字典

---

栈stack 和 队列queue

collections是Python内建的一个集合模块，里面封装了许多集合类，其中队列相关的集合只有一个deque。deque是双边队列(double-ended queue)，具有队列和栈的性质，在list的基础上增加了移动、旋转和增删等。

常用方法：

d = collections.deque([])

d.append('a'):在最右边添加一个元素

d.appendleft('b'):在最左边添加一个元素

d.extend(['c','d']):在最右边添加所有元素

d.extendleft(['e','f']):在最左边添加所有元素

d.pop():将最右边的元素取出

d.popleft():将最左边的元素取出

d.rotate(-2):向左旋转两个位置，正数向右旋转

d.count('a'):队列中a的个数

d.remove('c'):从队列中将c删除

d.reverse():将队列倒序

当要判断一个变量里面的 是不是 None 的时候,可以使用“ is ”这个关键字,也可以使用“==”。一般建议使用“ is ”关键字,因为速度会比”==＂稍微快一些。

字典
变量名[key]
变量名.get(key)
变量名.get(key, val) 在找不到key的情况下返回val
字典存储的数据是无序的

集合
无序，不能重复，可用于去重
集合最大的应用之一就是去重。例如,把一个带有重复元素的列表先转换为集合,再转换回列表,那么重复元素就只会保留一个。把列表转换为集合需要使用 set()函数,把集合转换为列表使用 list()函数
由于集合是无序的，去重的代价就是顺序会被打乱

4.使用字典实现多重条件控制
如果有多个 if ,写起来会很烦琐,例如下面这一段代码
if state == start :
code =1
elif state == running:
code =2
elif state == offline:
code =3
elif state == unknown:
code =4
else:
code =5
使用“ if . elif . else .”会让代码显得冗长。如果使用字典改写,代码就会变得非常简洁:
state_dict = { ‘start’ :1, ‘running’ :2, ‘offline’:3, ‘unknown’:4}
code = state_dict.get(state ,5)
for循环输出字典