02.python线性数据结构

阅读原文时间：2023年07月08日阅读：1

类型转换

int、float、complex、bool也可以当做内建函数对数据进行类型转换
int(x) 返回一个整数
float(x) 返回一个浮点数
complex(x)、complex(x,y) 返回一个复数
bool(x) 返回布尔值，前面讲过False等价的对象

取整

math模块的floor()、ceil()函数；内建函数int()、round()；运算符//

# 整除
print(3//2, 5//2, 7//2)
print(-3//2, -5//2, -7//2)
print(7//2, 7//-2, -7//2, -(7//2))
# int
print('int ------------')
print(int(1.4), int(1.5), int(1.6))
print(int(-1.4), int(-1.5), int(-1.6))
# ceil floor
print('ceil floor ------------')
import math
print(math.floor(2.5), math.floor(-2.5))
print(math.ceil(2.5), math.ceil(-2.5))
# round
print('round ------------')
print(round(1.4), round(-1.4), round(-1.6), round(1.6))

round()，四舍六入五取偶
math.floor()向下取整
math.ceil()向上取整
int() 取整数部分
// 整除且向下取整

常用数值处理函数

min()、max()
abs()
pow(x, y) 等于 x ** y
math.sqrt() 等于 x ** 0.5
进制函数，返回值是字符串
- bin()、oct()、hex()
math模块
- math.pi π
- math.e 自如常数
- math模块中还有对数函数、三角函数等
type(123) # 返回的是类型int
isinstance(456, int)
isinstance(True, (str, int, bool))
type(1 + True)
type(1 + True + 2.0) # 什么类型？

即使是强类型语言，也会有隐式类型转换。

线性表

线性表（简称表），是一种抽象的数学概念，是一组元素的序列的抽象，它由有穷个元素组成（0个或任意个）
顺序表：使用一大块连续的内存顺序存储表中的元素，这样实现的表称为顺序表，或称连续表

在顺序表中，元素的关系使用顺序表的存储顺序自然地表示
链接表：在存储空间中将分散存储的元素链接起来，这种实现称为链接表，简称链表

列表如同地铁站排好的队伍，有序，可以插队、离队，可以索引。

链表如同操场上手拉手的小朋友，有序但空间排列随意。或者可以想象成一串带线的珠子，随意盘放在桌上。也可以离队、插队，也可以索引。

对比体会一下，这两种数据结构的增删改查。

一个排列整齐的队伍，Python采用顺序表实现
列表内的个体称作元素，由若干元素组成列表
元素可以是任意对象（数字、字符串、对象、列表等）
列表内元素有顺序，可以使用索引
线性的数据结构
使用 [ ] 表示
列表是可变的

列表是非常重要的数据结构，对其内存结构和操作方法必须烂熟于心。

初始化

list() -> new empty list
list(iterable) -> new list initialized from iterable's items
[]
列表不能一开始就定义大小

索引

索引，也叫下标
正索引：从左至右，从0开始，为列表中每一个元素编号
如果列表有元素，索引范围[0, 长度-1]
负索引：从右至左，从-1开始
如果列表有元素，索引范围[-长度, -1]
正、负索引不可以超界，否则引发异常IndexError
为了理解方便，可以认为列表是从左至右排列的，左边是头部，右边是尾部，左边是下界，右边是上界
列表通过索引访问，list[index] ，index就是索引，使用中括号访问

使用索引定位访问元素的时间复杂度为O(1)，这是最快的方式，是列表最好的使用方式。

查询

index(value,[start,[stop]])
- 通过值value，从指定区间查找列表内的元素是否匹配
- 匹配第一个就立即返回索引
- 匹配不到，抛出异常ValueError
count(value)
- 返回列表中匹配value的次数
时间复杂度
- index和count方法都是O(n)
- 随着列表数据规模的增大，而效率下降
如何返回列表元素的个数？如何遍历？如何设计高效？

len()

修改

索引定位元素，然后修改。注意索引不能超界

ls1 = [1,2,3,4]
ls1[2] = 200

增加单个元素

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

增加多个元素

extend(iteratable) -> None
- 将可迭代对象的元素追加进来，返回None
- 就地修改，本列表自身扩展
+ -> list
- 连接操作，将两个列表连接起来，产生新的列表，原列表不变
- 本质上调用的是魔术方法__add__()方法
* -> list
- 重复操作，将本列表元素重复n次，返回新的列表
ls1 = [1] * 5
ls2 = [None] * 6
ls3 = [1,2] * 3
ls4 = [[1]] * 3

这个重复操作看似好用，如果原理掌握不好，但非常危险

x = [1] * 3
x[0] = 100
print(x) # 结果是什么


y = [[1]] * 3
print(y) # 结果是什么
y[0] = 100
print(y) # 结果是什么
y1 = 200
print(y) # 结果是什么

在Python中一切皆对象，而对象都是引用类型，可以理解为一个地址指针指向这个对象。

但是，字面常量字符串、数值等表现却不像引用类型，暂时可以称为简单类型。

而列表、元组、字典，包括以后学习的类和实例都可以认为是引用类型。

你可以认为简单类型直接存在列表中，而引入类型只是把引用地址存在了列表中。

删除

remove(value) -> None
- 从左至右查找第一个匹配value的值，找到就移除该元素，并返回None，否则ValueError
- 就地修改
- 效率？低
pop([index]) -> item
- 不指定索引index，就从列表尾部弹出一个元素
- 指定索引index，就从索引处弹出一个元素，索引超界抛出IndexError错误
- 效率？指定索引的的时间复杂度？不指定索引呢？
clear() -> None
- 清除列表所有元素，剩下一个空列表

反转

reverse() -> None
- 将列表元素反转，返回None
- 就地修改

这个方法最好不用，可以倒着读取，都不要反转。

排序

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

如果排序是必须的，那么排序。排序效率高吗？

in成员操作

'a' in ['a', 'b', 'c']
[3,4] in [1, 2, 3, [3,4]]
for x in [1,2,3,4]:
    pass

列表复制

a = list(range(4))
b = list(range(4))
print(a == b) c = a c[2] = 10
print(a)
print(a == b) # 还相等吗？
print(a == c) # 相等吗？

问题：

最终a 和 b相等吗？a和b分别存着什么元素
a 和 c 相等吗？为什么？ c = a 这一句有复制吗？

下面的程序a和b相等吗？

a = list(range(4))
b = a.copy()
print(a == b) a[2] = 10
print(a == b)


a = [1, [2, 3, 4], 5] b = a.copy()
print(a == b) a[2] = 10
print(a == b) a[2] = b[2]
print(a == b) a[1][1] = 100
print(a == b) # 还相等吗？
print(a)
print(b)

列表的内存模型和深浅拷贝

shadow copy
- 影子拷贝，也叫浅拷贝。遇到引用类型数据，仅仅复制一个引用而已
deep copy
- 深拷贝，往往会递归复制一定深度

一般情况下，大多数语言提供的默认复制行为都是浅拷贝。

import copy
a = [1, [2, 3], 4] b = copy.deepcopy(a)
print(a == b) a[1][1] = 100
print(a == b) # 还相等吗？
print(a)
print(b)

Python内建数据类型，内部都实现了 == ，它的意思是内容比较

random模块

randint(a, b) 返回[a, b]之间的整数
randrange ([start,] stop [,step]) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1。 random.randrange(1,7,2)
choice(seq) 从非空序列的元素中随机挑选一个元素，比如
- random.choice(range(10))，从0到9中随机挑选一个整数
- random.choice([1,3,5,7])
3.6开始提供choices，一次从样本中随机选择几个，可重复选择，可以指定权重
random.shuffle(list) ->None 就地打乱列表元素
sample(population, k) 从样本空间或总体（序列或者集合类型）中随机取出k个不同的元素，返回一个新的列表
- random.sample(['a', 'b', 'c', 'd'], 2)
- random.sample(['a', 'a'], 2) 会返回什么结果
- 每次从样本空间采样，在这一次中不可以重复抽取同一个元素
import random
for i in range(10):
print(random.randint(1, 5))
print('-' * 30)
for i in range(10):
print(random.randrange(1, 5))
print('-' * 30) x = [1, 2, 3, 4, 5]
for i in range(10):
print(random.choice(x))
print('-' * 30)

观察下面的0和1的比例

for i in range(10):
print(random.choices([0, 1], k=6))
print('-' * 30)
for i in range(10):
print(random.choices([0, 1], [10, 1], k=6)) # 10比1权重
x = [1, 2, 3, 4, 5]

采样

for i in range(5):
print(random.sample(x, 5)) # k能不能是6？
一个有序的元素组成的集合
使用小括号 ( ) 表示
元组是不可变对象

初始化

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

t1 = () # 空元组
t2 = (1,) # 必须有这个逗号
t3 = (1,) * 5
t4 = (1, 2, 3)
t5 = 1, 'a'
t6 = (1, 2, 3, 1, 2, 3)
t7 = tuple() # 空元组
t8 = tuple(range(5))
t9 = tuple([1,2,3])

索引

索引和列表规则一样，不可以超界

查询

方法和列表一样，时间复杂度也一样。index、count、len等

增删改

元组元素的个数在初始化的时候已经定义好了，所以不能为元组增加元素、也不能从中删除元素、也不能修改元素的内容。

但是要注意下面这个例子

t1 = ([1]) * 3
t1[1] = 100 # ?
# 注意下面的例子
t2 = ([1],) * 3
print(t2)
t2[1] = 100
t2[0][0] = 100
print(t2)

上例说明t2是可变的吗？不是说元组不可变吗？到底什么不可变

一个个字符组成的有序的序列，是字符的集合
使用单引号、双引号、三引号引住的字符序列
字符串是不可变对象，是字面常量

Python3起，字符串都是Unicode类型

初始化

s1 = 'string'
s2 = "string2"
s3 = '''this's a "String" '''
s4 = 'hello \n magedu.com'
s5 = r"hello \n magedu.com"
s6 = 'c:\windows\nt'
s7 = R"c:\windows\nt"
s8 = 'c:\windows\\nt'
name = 'tom'; age = 20 # python代码写在一行，使用分号隔开，不推荐
s9 = f'{name}, {age}' # 3.6支持f前缀
sql = """select * from user where name='tom' """

r前缀：所有字符都是本来的意思，没有转义

f前缀：3.6开始，使用变量插值

索引

字符串是序列，支持下标访问。但不可变，不可以修改元素。

sql = "select * from user where name='tom'"
print(sql[4]) # 字符串'c'
sql[4] = 'o' # 不可以

连接

加号
- 将2个字符串连接起来
返回一个新的字符串
join方法
- sep.join(iterable)
- 使用指定字符串作为分隔符，将可迭代对象中字符串使用这个分隔符拼接起来
- 可迭代对象必须是字符串
- 返回一个新的字符串

字符查找

find(sub[, start[, end]]) -> int
- 在指定的区间[start, end)，从左至右，查找子串sub
- 找到返回正索引，没找到返回-1
rfind(sub[, start[, end]]) -> int
- 在指定的区间[start, end)，从右至左，查找子串sub
- 找到返回正索引，没找到返回-1
s = 'magedu.edu'
print(s.find('edu'))
print(s.find('edu', 3))
print(s.find('edu', 4))
print(s.find('edu', 6, 9))
print(s.find('edu', 7, 20))
print(s.find('edu', 200))
s = 'magedu.edu'
print(s.rfind('edu'))
print(s.rfind('edu', 3))
print(s.rfind('edu', 4))
print(s.rfind('edu', 6, 9))
print(s.rfind('edu', 7, 20))
print(s.rfind('edu', 200))

这两个方法只是找字符串的方向不同，返回值一样。找到第一个满足要求的子串立即返回。特别注意返

回值，找不到返回的是负数-1。

这两个方法效率高吗？要不要用？

这两个方法效率真不高，都是在字符串中遍历搜索，但是如果找子串工作必不可少，那么必须这么做，

但是能少做就少做。

index(sub[, start[, end]]) -> int
- 在指定的区间[start, end)，从左至右，查找子串sub
- 找到返回正索引，没找到抛出异常ValueError
rindex(sub[, start[, end]]) -> int
- 在指定的区间[start, end)，从左至右，查找子串sub
- 找到返回正索引，没找到抛出异常ValueError

index方法和find方法很像，不好的地方在于找不到抛异常。推荐使用find方法。

s = 'magedu.edu'
print(s.index('edu'))
print(s.index('edu', 3))
print(s.index('edu', 4))
#print(s.index('edu', 6, 9)) # 抛异常
print(s.index('edu', 7, 20))
#print(s.index('edu', 200)) # 抛异常

count(sub[, start[, end]]) -> int
- 在指定的区间[start, end)，从左至右，统计子串sub出现的次数
s = 'magedu.edu'
print(s.count('edu'))
print(s.count('edu', 4))
时间复杂度
- find、index和count方法都是O(n)
- 随着字符串数据规模的增大，而效率下降
len(string)
- 返回字符串的长度，即字符的个数

分割

split(sep=None, maxsplit=-1) -> list of strings
- 从左至右
- sep 指定分割字符串，缺省的情况下空白字符串作为分隔符
- maxsplit 指定分割的次数，-1 表示遍历整个字符串
- 立即返回列表
rsplit(sep=None, maxsplit=-1) -> list of strings
- 从右向左开始切，但是输出的字符串字符不会反
- sep 指定分割字符串，缺省的情况下空白字符串作为分隔符
- maxsplit 指定分割的次数，-1 表示遍历整个字符串
- 立即返回列表
splitlines([keepends]) -> list of strings
- 按照行来切分字符串
- keepends 指的是是否保留行分隔符
- 行分隔符包括\n、\r\n、\r等
s = ','.join('abcd')
print(s.split(','))
print(s.split())
print(s.split(',', 2))
s1 = '\na b \tc\nd\n' # 注意下面3个切割的区别
print(s1.split())
print(s1.split(' '))
print(s1.split('\n'))
print(s1.split('b'))
print(s1.splitlines())
partition(sep) -> (head, sep, tail)
- 从左至右，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组
- 如果没有找到分隔符，就返回头、2个空元素的三元组
- sep 分割字符串，必须指定
rpartition(sep) -> (head, sep, tail)
- 从右至左，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组
- 如果没有找到分隔符，就返回2个空元素和尾的三元组
s = ','.join('abcd')
print(s.partition(','))
print(s.partition('.'))
print(s.rpartition(','))
print(s.rpartition('.'))

替换

replace(old, new[, count]) -> str
- 字符串中找到匹配替换为新子串，返回新字符串
- count表示替换几次，不指定就是全部替换
s = ','.join('abcd')
print(s.replace(',', ' '))
print(s.replace(',', ' ', 2))
s1 = 'www.magedu.edu'
print(s1.replace('w', 'a'))
print(s1.replace('ww', 'a'))
print(s1.replace('ww', 'w')) # 返回什么？
print(s1.replace('www', 'a'))

移除

strip([chars]) -> str
- 在字符串两端去除指定的字符集chars中的所有字符
- 如果chars没有指定，去除两端的空白字符
lstrip([chars]) -> str ，从左开始
rstrip([chars]) -> str，从右开始

s = '\t\r\na b c,d\ne\n\t'
print(s.strip())
print('-' * 30)
print(s.strip('\t\n'))
print('-' * 30)
print(s.strip('\t\ne\r'))

首尾判断

endswith(suffix[, start[, end]]) -> bool
- 在指定的区间[start, end)，字符串是否是suffix结尾
startswith(prefix[, start[, end]]) -> bool
- 在指定的区间[start, end)，字符串是否是prefix开头
s = "www.magedu.edu"
print(s.startswith('ww'))
print(s.startswith('e', 7))
print(s.startswith('e', 10))
print(s.startswith('edu', 11))
print(s.endswith('edu'))

其它函数

upper()大写
lower()小写
swapcase() 交换大小写
isalnum() -> bool 是否是字母和数字组成
isalpha() 是否是字母
isdecimal() 是否只包含十进制数字
isdigit() 是否全部数字(0~9)
isidentifier() 是不是字母和下划线开头，其他都是字母、数字、下划线
islower() 是否都是小写
isupper() 是否全部大写
isspace() 是否只包含空白字符

其他格式打印函数中文几乎不用，大家自行查看帮助

简单的使用+或者join也可以拼接字符串，但是需要先转换数据到字符串后才能拼接。

C风格printf-style

占位符：使用%和格式字符，例如%s、%d
修饰符：在占位符中还可以插入修饰符，例如%03d
format % values
- format是格式字符串，values是被格式的值
- 格式字符串和被格式的值之间使用%
- values只能是一个对象，可以是一个值，可以是一个元素个数和占位符数目相等的元组，也可以是一个字典
"I am %03d" % (20,)
'I like %s.' % 'Python'
"%3.2f%% 0x%x %#X" % (89.7654, 10, 256) # 宽度为3，小数点后2位
"I am %-5d" % (20,)
"%(host)s.%(domain)s" % {'domain':'magedu.com', 'host':'www'} # 靠名字对应

format函数

Python2.5之后，字符串类型提供了format函数，功能更加强大，鼓励使用。

"{} {xxx}".format(*args, **kwargs) -> str

args是可变的位置参数
kwargs是可变关键字参数，写作a=100
使用花括号作为占位符
{}表示按照顺序匹配位置参数，{n}表示取位置参数索引为n的值
{xxx}表示在关键字参数中搜索名称一致的
{{}} 表示打印花括号

位置对应

"{}:{}".format('127.0.0.1', 8080)

位置或关键字对应

"{server} {1}:{0}".format(8080, '127.0.0.1', server='Web Server Info: ')

访问元素

"{0[0]}.{0[1]}".format(('magedu', 'com'))

进制

"{0:d} {0:b} {0:o} {0:x} {0:#X}".format(31)

浮点数

print("{}".format(30.5)) # 1.7320508075688772 print("{:f}".format(30.5)) # 1.732051，精度默认6
print("{:10f}".format(30.5)) # 右对齐，宽度10 print("{:2}".format(102.231)) # 宽度为2数字 print("{:2}".format(1)) # 宽度为2数字 print("{:.2}".format(30.5)) # 1.7 2个数字
print("{:.2f}".format(30.5)) # 1.73 小数点后2位 print("{:3.2f}".format(30.5)) # 1.73 宽度为3，小数点后2位
print("{:20.3f}".format(0.2745)) # 0.275
print("{:3.3%}".format(1/3)) # 33.333%

注意宽度可以被撑破

对齐

print("{}{}={}".format(5, 6, 56))
print("{}{}={:2}".format(5, 6, 56))
print("{1}{0}={2:3}".format(5, 6, 56))
print("{1}{0}={2:0>3}".format(5, 6, 56))
print("{}{}={:#<3}".format(4, 5, 20)) print("{:#^7}".format('' * 3))

Python3 引入两个新的类型bytes、bytearray。

bytes不可变字节序列；bytearray是可变字节数组。

编码与解码

编码：str => bytes，将字符串这个字符序列使用指定字符集encode编码为一个个字节组成的序列bytes
解码：bytes或bytearray => str，将一个个字节按照某种指定的字符集解码为一个个字符串组成的字符串

print("abc".encdoe()) # 缺省为utf-8编码
print("啊".encode('utf-8'))
print("啊".encode('gbk'))
print(b'abc'.decode('utf8'))
print(b'\xb0\xa1'.decode('gbk'))

ASCII

ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是基于拉丁字母的一套单字节编码系统

基本ASCII码

前128个称为基本ASCII码，从二进制角度来看，它们的最高位bit[7]=0，只使用了低7位bit[6,0]来进行编码。

0~31 之间的ASCII码常用于控制像打印机一样的外围设备。

十进制DEC

八进制OCT

十六进制HEX

二进制BIN

符号Symbol

HTML实体编码

中文解释Description

000

00000000

NUL

�

空字符

001

00000001

SOH

�

标题开始

002

00000010

STX

�

正文开始

003

00000011

ETX

�

正文结束

004

00000100

EOT

�

传输结束

005

00000101

ENQ

�

询问

006

00000110

ACK

�

收到通知

007

00000111

BEL

�

铃

010

00001000

�

退格

011

00001001

水平制表符

012

00001010

换行键

013

00001011

�

垂直制表符

014

00001100

换页键

015

00001101

回车键

016

00001110

�

移出

017

00001111

�

移入

020

00010000

DLE

�

数据链路转义

021

00010001

DC1

�

设备控制 1

022

00010010

DC2

�

设备控制 2

023

00010011

DC3

�

设备控制 3

024

00010100

DC4

�

设备控制 4

025

00010101

NAK

�

拒绝接收

026

00010110

SYN

�

同步空闲

027

00010111

ETB

�

传输块结束

030

00011000

CAN

�

取消

031

00011001

�

介质中断

032

00011010

SUB

�

替换

033

00011011

ESC

�

换码符

034

00011100

�

文件分隔符

035

00011101

�

组分隔符

036

00011110

�

记录分离符

037

00011111

�

单元分隔符

32~127 之间的ASCII码表示的符号，在我们的键盘上都可以被找到。其中：32表示空格，127表示删除命令。

十进制DEC

八进制OCT

十六进制HEX

二进制BIN

符号Symbol

HTML实体编码

中文解释Description

040

00100000

空格

041

00100001

感叹号

042

00100010

双引号

043

00100011

井号

044

00100100

美元符

045

00100101

百分号

046

00100110

与

047

00100111

单引号

050

00101000

(

左括号

051

00101001

)

右括号

052

00101010

星号

053

00101011

加号

054

00101100

逗号

055

00101101

连字号或减号

056

00101110

句点或小数点

057

00101111

斜杠

060

00110000

061

00110001

062

00110010

063

00110011

064

00110100

065

00110101

066

00110110

067

00110111

070

00111000

071

00111001

072

00111010

冒号

073

00111011

;

分号

074

00111100

小于

075

00111101

等号

076

00111110

大于

077

00111111

问号

100

01000000

电子邮件符号

101

01000001

大写字母 A

102

01000010

大写字母 B

103

01000011

大写字母 C

104

01000100

大写字母 D

105

01000101

大写字母 E

106

01000110

大写字母 F

107

01000111

大写字母 G

110

01001000

大写字母 H

111

01001001

大写字母 I

112

01001010

大写字母 J

113

01001011

大写字母 K

114

01001100

大写字母 L

115

01001101

大写字母 M

116

01001110

大写字母 N

117

01001111

大写字母 O

120

01010000

大写字母 P

121

01010001

大写字母 Q

122

01010010

大写字母 R

123

01010011

大写字母 S

124

01010100

大写字母 T

125

01010101

大写字母 U

126

01010110

大写字母 V

127

01010111

&#087

大写字母 W

130

01011000

大写字母 X

131

01011001

大写字母 Y

132

01011010

大写字母 Z

133

01011011

[

左中括号

134

01011100

反斜杠

135

01011101

]

右中括号

136

01011110

音调符号

137

01011111

下划线

140

01100000

重音符

141

01100001

小写字母 a

142

01100010

小写字母 b

143

01100011

小写字母 c

100

144

01100100

小写字母 d

101

145

01100101

小写字母 e

102

146

01100110

小写字母 f

103

147

01100111

小写字母 g

104

150

01101000

小写字母 h

105

151

01101001

小写字母 i

106

152

01101010

小写字母 j

107

153

01101011

小写字母 k

108

154

01101100

小写字母 l

109

155

01101101

小写字母 m

110

156

01101110

小写字母 n

111

157

01101111

小写字母 o

112

160

01110000

小写字母 p

113

161

01110001

小写字母 q

114

162

01110010

小写字母 r

115

163

01110011

小写字母 s

116

164

01110100

小写字母 t

117

165

01110101

小写字母 u

118

166

01110110

小写字母 v

119

167

01110111

小写字母 w

120

170

01111000

小写字母 x

121

171

01111001

小写字母 y

122

172

01111010

小写字母 z

123

173

01111011

{

左大括号

124

174

01111100

垂直线

125

175

01111101

}

右大括号

126

176

01111110

波浪号

127

177

01111111

�

删除

扩展ASCII码

后128个称为扩展ASCII码。许多基于x86的系统都支持使用扩展（或“高”）ASCII。扩展ASCII码允许将每个字符的第8 位用于确定附加的128 个特殊符号字符、外来语字母和图形符号

十进制DEC

八进制OCT

十六进制HEX

二进制BIN

符号Symbol

HTML实体编码

中文解释Description

128

200

10000000

€

�

欧盟符号

129

201

10000001

130

202

10000010

‚

�

单低 9 引号

131

203

10000011

�

带钩的拉丁小写字母f

132

204

10000100

„

�

双低 9 引号

133

205

10000101

…

�

水平省略号

134

206

10000110

†

�

剑号

135

207

10000111

‡

�

双剑号

136

210

10001000

�

修正字符抑扬音符号

137

211

10001001

‰

�

千分号

138

212

10001010

�

带弯音号的拉丁大写字母 S

139

213

10001011

‹

�

左单书名号

140

214

10001100

�

拉丁大写组合 OE

141

215

10001101

142

216

10001110

�

带弯音号的拉丁大写字母 z

143

217

10001111

144

220

10010000

145

221

10010001

‘

�

左单引号

146

222

10010010

’

�

右单引号

147

223

10010011

“

�

左双引号

148

224

10010100

”

�

右双引号

149

225

10010101

•

�

150

226

10010110

–

�

半长破折号

151

227

10010111

—

�

全长破折号

152

230

10011000

�

小波浪线

153

231

10011001

�

154

232

10011010

�

带弯音号的拉丁小写字母 s

155

233

10011011

›

�

右单书名号

156

234

10011100

�

拉丁小写组合 oe

157

235

10011101

158

236

10011110

�

带弯音号的拉丁小写字母 z

159

237

10011111

�

带弯音号的拉丁大写字母 Y

160

240

10100000

161

241

10100001

反向感叹号

162

242

10100010

分币符号

163

243

10100011

英磅符号

164

244

10100100

165

245

10100101

人民币符号

166

246

10100110

167

247

10100111

章节符号

168

250

10101000

通用货币符号

169

251

10101001

版权符号

170

252

10101010

阴性顺序指示符号

171

253

10101011

左角引号

172

254

10101100

173

255

10101101

174

256

10101110

175

257

10101111

176

260

10110000

温度符号

177

261

10110001

加/减号

178

262

10110010

上标 2

179

263

10110011

上标 3

180

264

10110100

181

265

10110101

微符号

182

266

10110110

段落符号，pilcrow

183

267

10110111

中点

184

270

10111000

185

271

10111001

上标 1

186

272

10111010

阳性顺序指示符

187

273

10111011

右角引号

188

274

10111100

分数四分之一

189

275

10111101

分数二分之一

190

276

10111110

191

277

10111111

反向问号

192

300

11000000

带重音符的大写字母 A

193

301

11000001

带尖锐重音的大写字母 A

194

302

11000010

带音调符号的大写字母 A

195

303

11000011

带代字号的大写字母 A

196

304

11000100

带元音变音(分音符号)的大写字母 A

197

305

11000101

带铃声的大写字母 A

198

306

11000110

大写字母 AE双重元音

199

307

11000111

带变音符号的大写字母 C

200

310

11001000

带重音符的大写字母 E

201

311

11001001

带尖锐重音的大写字母 E

202

312

11001010

带音调符号的大写字母 E

203

313

11001011

带元音变音(分音符号)的大写字母 E

204

314

11001100

带重音符的大写字母 I

205

315

11001101

带尖锐重音的大写字母 I

206

316

11001110

带音调符号的大写字母 I

207

317

11001111

带元音变音(分音符号)的大写字母 I

208

320

11010000

209

321

11010001

带代字号的大写字母 N

210

322

11010010

带重音符的大写字母 O

211

323

11010011

带尖锐重音的大写字母 O

212

324

11010100

带音调符号的大写字母 O

213

325

11010101

带代字号的大写字母 O

214

326

11010110

带元音变音(分音符号)的大写字母 O

215

327

11010111

大写字母OE 连字

216

330

11011000

带斜杠的大写字母 O

217

331

11011001

带重音符的大写字母 U

218

332

11011010

带尖锐重音的大写字母 U

219

333

11011011

带音调符号的大写字母 U

220

334

11011100

带元音变音(分音符号)的大写字母 U

221

335

11011101

带元音变音(分音符号)的大写字母 Y

222

336

11011110

223

337

11011111

德语高调小写字母 s

224

340

11100000

带重音符的小写字母 a

225

341

11100001

带尖锐重音的小写字母 a

226

342

11100010

带音调符号的小写字母 a

227

343

11100011

带代字号的小写字母 a

228

344

11100100

带元音变音(分音符号)的小写字母 a

229

345

11100101

带铃声的小写字母 a

230

346

11100110

小写字母 ae双重元音

231

347

11100111

带变音符号的小写字母 c

232

350

11101000

带重音符的小写字母 e

233

351

11101001

带尖锐重音的小写字母 e

234

352

11101010

带音调符号的小写字母 e

235

353

11101011

带元音变音(分音符号)的小写字母 e

236

354

11101100

带重音符的小写字母 i

237

355

11101101

带尖锐重音的小写字母 i

238

356

11101110

带音调符号的小写字母 i

239

357

11101111

带元音变音(分音符号)的小写字母 i

240

360

11110000

241

361

11110001

带代字号的小写字母 n

242

362

11110010

带重音符的小写字母 o

243

363

11110011

带尖锐重音的小写字母 o

244

364

11110100

带音调符号的小写字母 o

245

365

11110101

带代字号的小写字母 o

246

366

11110110

带元音变音(分音符号)的小写字母 o

247

367

11110111

小写字母 oe连字

248

370

11111000

带斜杠的小写字母 o

249

371

11111001

带重音符的小写字母 u

250

372

11111010

带尖锐重音的小写字母 u

251

373

11111011

带音调符号的小写字母 u

252

374

11111100

带元音变音(分音符号)的小写字母 u

253

375

11111101

带元音变音(分音符号)的小写字母 y2

254

376

11111110

255

377

11111111

重点

\x00是ASCII表中第一项，C语言中的字符串结束符
\t、\x09，表示tab字符
\r\n是\x0d\x0a
\x30~\x39 字符0~9，\x31是字符1
\x41对应十进制65，表示A
\x61对应十进制97，表示a

注意：这里的1指定是字符1，不是数字1

UTF-8、GBK都兼容了ASCII

'a\x09b\x0d\x0ac \x31\x41\x61' # 表示什么？
'A' > 'a' # 谁大？

Bytes初始化

bytes() 空bytes
bytes(int) 指定字节的bytes，被0填充
bytes(iterable_of_ints) -> bytes [0,255]的int组成的可迭代对象
bytes(string, encoding[, errors]) -> bytes 等价于string.encode()
bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer 从一个字节序列或者buffer复制出一个新的不可变的bytes对象
使用b前缀定义
- 只允许基本ASCII使用字符形式b'abc9'
- 使用16进制转义表示b"\x41\x61"

bytes类型和str类型类似，都是不可变类型，操作方法类似。

print(b'abcd'[2]) # 返回int，指定是本字节对应的十进制数
x = b'\t\x09'
print(x, len(x))
y = br'\t\x09'
print(y, len(y))

bytearray初始化

bytearray() 空bytearray
bytearray(int) 指定字节的bytearray，被0填充
bytearray(iterable_of_ints) -> bytearray [0,255]的int组成的可迭代对象
bytearray(string, encoding[, errors]) -> bytearray 近似string.encode()，不过返回可变对象
bytearray(bytes_or_buffer) 从一个字节序列或者buffer复制出一个新的可变的bytearray对象

b前缀表示的是bytes，不是bytearray类型

由于bytearray类型是可变数组，所以，类似列表。

append(int) 尾部追加一个元素
insert(index, int) 在指定索引位置插入元素
extend(iterable_of_ints) 将一个可迭代的整数集合追加到当前bytearray
pop(index=-1) 从指定索引上移除元素，默认从尾部移除
remove(value) 找到第一个value移除，找不到抛ValueError异常
注意：上述方法若需要使用int类型，值在[0, 255]
clear() 清空bytearray
reverse() 翻转bytearray，就地修改

b = bytearray()
b.append(97) b.append(99) b.insert(1,98) b.extend([65,66,67])
b.remove(66) b.pop()
b.reverse()
print(b) # 输出什么
b.clear()

线性结构特征：

可迭代 for … in
有长度，通过len(x)获取，容器
通过整数下标可以访问元素。正索引、负索引
- 可以切片

已经学习过的线性结构：list、tuple、str、bytes、bytearray

切片

sequence[start:stop]
sequence[start:stop:step]

通过给定的索引区间获得线性结构的一部分数据
start、stop、step为整数，可以是正整数、负整数、零
start为0时，可以省略
stop为末尾时，可以省略
step为1时，可以省略
切片时，索引超过上界（右边界），就取到末尾；超过下界（左边界），取到开头

x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x[:])
print(x[:-1]) #
print(x[0:])
print(x[3:])
print(x[3:-1]) #
print(x[9:])
print(x[:9])
print(x[9:-1])
print(x[:100])
print(x[-100:])
print(x[4:-2])
print(x[-4:-2])
print('0123456789'[-4:8])
print(b'0123456789'[-4:8])
print(bytearray(b'0123456789')[-10:5])

步长

x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x[::])
print(x[::2])
print(x[2:8:3])
print(x[:9:3])
print(x[1::3])
print(x[-10:8:2])

起止和方向

x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x[-10:])
print(x[-5:6])
print(x[-5:-6])
print(x[6:5])
print(x[5:5])
print(x[1:9:-2])
print(x[::-2])
print(x[8::-2]) # 表示索引8到左尽头，包含0
print(x[8:0:-2]) # 表示索引8到索引1，不含0
print(x[8:-10:2])
print(x[8:-10:-2])
print(x[-5:4:-1])
print(x[-5:5:-1])

在序列上使用切片[start:stop]，子区间索引范围[start, stop)，相当于从start开始指向stop的方向上获取数据

默认step为1，表示向右；步长为负数，表示向左

如果子区间方向和步长方向不一致，直接返回当前类型的"空对象"

如果子区间方向和步长方向一致，则从起点间隔步长取值

内建函数

函数签名

说明

id(object)

CPython中返回对象的内存地址可以用来判断是不是同一个对象

# 使用id看地址，要注意地址回收复用问题
print(id([1,2,3]))
print(id([4,5,6,7]))
# 上下两句可能内存地址一样，但是上面那个[1,2,3]没有意义，因为它用完之后，引用计数为0了，没
人能再次访问到，释放了内存
# 如果2个存在在内存中的对象，地址一样一定是同一个对象

本质

x = [0, 1, 2] y = x[:]
print(x, y)
print(id(x), id(y))
x[0] = 100
print(x, y) x = [[1]]
y = x[:]
print(x, y)
print(x == y)
print(id(x), id(y), x is y) x[0][0] = 100
print(x, y)
print(x == y)
print(x is y) x[0] = 200
print(x == y) # ?
print(x, y)

上例可知，实际上切片后得到一个全新的对象。 [:] 或 [::] 相当于copy方法。

99乘法表

if __name__ == '__main__':
    for x in range(1,10):
        for y in range(1,x+1):
            print("{} * {} = {:<10}".format(x,y,x*y), end='' if x>y else '\n')

100奇数和

if __name__ == '__main__':
    sum=0
    for i in range(1,100,2):
        sum+=i
    print(sum)
#或者
print(sum(range(1,100,2)))

手机扫一扫

移动阅读更方便

你可能感兴趣的文章

【python基础】循环语句-continue关键字

Python 自动化测试的配置层实现方式对标与落地

Python运维开发之路《模块》

2023CISCN华中赛区re

最常用的Linux命令

C++内敛函数，构造函数，析构函数，浅拷贝

针对sarasa-shuffle.woff2加密字体进行解密

2.0 Python 数据结构与类型

如何在 Linux 中查看目录大小？

一分钟学一个 Linux 命令 - find 和 grep

02.python线性数据结构

分类

数值型

序列sequence

键值对

类型转换

取整

常用数值处理函数

线性表

初始化

索引

查询

修改

增加单个元素

增加多个元素

删除

反转

排序

in成员操作

列表复制

列表的内存模型和深浅拷贝

观察下面的0和1的比例

采样

初始化

索引

查询

增删改

初始化

索引

连接

字符查找

分割

替换

移除

首尾判断

其它函数

C风格printf-style

format函数

位置对应

位置或关键字对应

访问元素

进制

浮点数

注意宽度可以被撑破

对齐

编码与解码

ASCII

基本ASCII码

扩展ASCII码

重点

Bytes初始化

bytearray初始化

切片

步长

起止和方向

本质

99乘法表

100奇数和