02.python线性数据结构、列表list、元祖tuple、字符串str、字节bytes、字节列表bytearray、
内建常用数据类型
分类
数值型
- int、float、complex、bool
序列sequence
- 字符串str、字节序列bytes、bytearray
- 列表list、元组tuple
键值对
- 集合set、字典dict
数值型
- int、float、complex、bool都是class,1、5.0、2+3j都是对象即实例
- int:python3的int就是长整型,且没有大小限制,受限于内存区域的大小
- float:由整数部分和小数部分组成。支持十进制和科学计数法表示。C的双精度型实现
- complex:有实数和虚数部分组成,实数和虚数部分都是浮点数,3+4.2J
- bool:int的子类,仅有2个实例True、False对应1和0,可以和整数直接运算
类型转换
- 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个或任意个)
-
顺序表:使用一大块连续的内存顺序存储表中的元素,这样实现的表称为顺序表,或称连续表
在顺序表中,元素的关系使用顺序表的存储顺序自然地表示
-
链接表:在存储空间中将分散存储的元素链接起来,这种实现称为链接表,简称链表
列表如同地铁站排好的队伍,有序,可以插队、离队,可以索引。
链表如同操场上手拉手的小朋友,有序但空间排列随意。或者可以想象成一串带线的珠子,随意盘放在桌上。也可以离队、插队,也可以索引。
对比体会一下,这两种数据结构的增删改查。
列表list
- 一个排列整齐的队伍,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
- 一个有序的元素组成的集合
- 使用小括号 ( ) 表示
- 元组是不可变对象
初始化
- 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是可变的吗?不是说元组不可变吗?到底什么不可变
字符串str
- 一个个字符组成的有序的序列,是字符的集合
- 使用单引号、双引号、三引号引住的字符序列
- 字符串是不可变对象,是字面常量
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(3**0.5)) # 1.7320508075688772 print("{:f}".format(3**0.5)) # 1.732051,精度默认6 print("{:10f}".format(3**0.5)) # 右对齐,宽度10 print("{:2}".format(102.231)) # 宽度为2数字 print("{:2}".format(1)) # 宽度为2数字 print("{:.2}".format(3**0.5)) # 1.7 2个数字 print("{:.2f}".format(3**0.5)) # 1.73 小数点后2位 print("{:3.2f}".format(3**0.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, 5*6)) print("{}*{}={:2}".format(5, 6, 5*6)) print("{1}*{0}={2:3}".format(5, 6, 5*6)) print("{1}*{0}={2:0>3}".format(5, 6, 5*6)) 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 |
---|---|---|---|---|---|---|
0 | 000 | 00 | 00000000 | NUL | � | 空字符 |
1 | 001 | 01 | 00000001 | SOH | � | 标题开始 |
2 | 002 | 02 | 00000010 | STX | � | 正文开始 |
3 | 003 | 03 | 00000011 | ETX | � | 正文结束 |
4 | 004 | 04 | 00000100 | EOT | � | 传输结束 |
5 | 005 | 05 | 00000101 | ENQ | � | 询问 |
6 | 006 | 06 | 00000110 | ACK | � | 收到通知 |
7 | 007 | 07 | 00000111 | BEL | � | 铃 |
8 | 010 | 08 | 00001000 | BS | � | 退格 |
9 | 011 | 09 | 00001001 | HT | 水平制表符 | |
10 | 012 | 0A | 00001010 | LF | 换行键 | |
11 | 013 | 0B | 00001011 | VT | � | 垂直制表符 |
12 | 014 | 0C | 00001100 | FF | 换页键 | |
13 | 015 | 0D | 00001101 | CR | 回车键 | |
14 | 016 | 0E | 00001110 | SO | � | 移出 |
15 | 017 | 0F | 00001111 | SI | � | 移入 |
16 | 020 | 10 | 00010000 | DLE | � | 数据链路转义 |
17 | 021 | 11 | 00010001 | DC1 | � | 设备控制 1 |
18 | 022 | 12 | 00010010 | DC2 | � | 设备控制 2 |
19 | 023 | 13 | 00010011 | DC3 | � | 设备控制 3 |
20 | 024 | 14 | 00010100 | DC4 | � | 设备控制 4 |
21 | 025 | 15 | 00010101 | NAK | � | 拒绝接收 |
22 | 026 | 16 | 00010110 | SYN | � | 同步空闲 |
23 | 027 | 17 | 00010111 | ETB | � | 传输块结束 |
24 | 030 | 18 | 00011000 | CAN | � | 取消 |
25 | 031 | 19 | 00011001 | EM | � | 介质中断 |
26 | 032 | 1A | 00011010 | SUB | � | 替换 |
27 | 033 | 1B | 00011011 | ESC | � | 换码符 |
28 | 034 | 1C | 00011100 | FS | � | 文件分隔符 |
29 | 035 | 1D | 00011101 | GS | � | 组分隔符 |
30 | 036 | 1E | 00011110 | RS | � | 记录分离符 |
31 | 037 | 1F | 00011111 | US | � | 单元分隔符 |
32~127 之间的ASCII码表示的符号,在我们的键盘上都可以被找到。其中:32表示空格,127表示删除命令。
十进制DEC | 八进制OCT | 十六进制HEX | 二进制BIN | 符号Symbol | HTML实体编码 | 中文解释Description |
---|---|---|---|---|---|---|
32 | 040 | 20 | 00100000 | 空格 | ||
33 | 041 | 21 | 00100001 | ! | ! | 感叹号 |
34 | 042 | 22 | 00100010 | " | " | 双引号 |
35 | 043 | 23 | 00100011 | # | # | 井号 |
36 | 044 | 24 | 00100100 | $ | $ | 美元符 |
37 | 045 | 25 | 00100101 | % | % | 百分号 |
38 | 046 | 26 | 00100110 | & | & | 与 |
39 | 047 | 27 | 00100111 | ' | ' | 单引号 |
40 | 050 | 28 | 00101000 | ( | ( | 左括号 |
41 | 051 | 29 | 00101001 | ) | ) | 右括号 |
42 | 052 | 2A | 00101010 | * | * | 星号 |
43 | 053 | 2B | 00101011 | + | + | 加号 |
44 | 054 | 2C | 00101100 | , | , | 逗号 |
45 | 055 | 2D | 00101101 | - | - | 连字号或减号 |
46 | 056 | 2E | 00101110 | . | . | 句点或小数点 |
47 | 057 | 2F | 00101111 | / | / | 斜杠 |
48 | 060 | 30 | 00110000 | 0 | 0 | 0 |
49 | 061 | 31 | 00110001 | 1 | 1 | 1 |
50 | 062 | 32 | 00110010 | 2 | 2 | 2 |
51 | 063 | 33 | 00110011 | 3 | 3 | 3 |
52 | 064 | 34 | 00110100 | 4 | 4 | 4 |
53 | 065 | 35 | 00110101 | 5 | 5 | 5 |
54 | 066 | 36 | 00110110 | 6 | 6 | 6 |
55 | 067 | 37 | 00110111 | 7 | 7 | 7 |
56 | 070 | 38 | 00111000 | 8 | 8 | 8 |
57 | 071 | 39 | 00111001 | 9 | 9 | 9 |
58 | 072 | 3A | 00111010 | : | : | 冒号 |
59 | 073 | 3B | 00111011 | ; | ; | 分号 |
60 | 074 | 3C | 00111100 | < | < | 小于 |
61 | 075 | 3D | 00111101 | = | = | 等号 |
62 | 076 | 3E | 00111110 | > | > | 大于 |
63 | 077 | 3F | 00111111 | ? | ? | 问号 |
64 | 100 | 40 | 01000000 | @ | @ | 电子邮件符号 |
65 | 101 | 41 | 01000001 | A | A | 大写字母 A |
66 | 102 | 42 | 01000010 | B | B | 大写字母 B |
67 | 103 | 43 | 01000011 | C | C | 大写字母 C |
68 | 104 | 44 | 01000100 | D | D | 大写字母 D |
69 | 105 | 45 | 01000101 | E | E | 大写字母 E |
70 | 106 | 46 | 01000110 | F | F | 大写字母 F |
71 | 107 | 47 | 01000111 | G | G | 大写字母 G |
72 | 110 | 48 | 01001000 | H | H | 大写字母 H |
73 | 111 | 49 | 01001001 | I | I | 大写字母 I |
74 | 112 | 4A | 01001010 | J | J | 大写字母 J |
75 | 113 | 4B | 01001011 | K | K | 大写字母 K |
76 | 114 | 4C | 01001100 | L | L | 大写字母 L |
77 | 115 | 4D | 01001101 | M | M | 大写字母 M |
78 | 116 | 4E | 01001110 | N | N | 大写字母 N |
79 | 117 | 4F | 01001111 | O | O | 大写字母 O |
80 | 120 | 50 | 01010000 | P | P | 大写字母 P |
81 | 121 | 51 | 01010001 | Q | Q | 大写字母 Q |
82 | 122 | 52 | 01010010 | R | R | 大写字母 R |
83 | 123 | 53 | 01010011 | S | S | 大写字母 S |
84 | 124 | 54 | 01010100 | T | T | 大写字母 T |
85 | 125 | 55 | 01010101 | U | U | 大写字母 U |
86 | 126 | 56 | 01010110 | V | V | 大写字母 V |
87 | 127 | 57 | 01010111 | W | W | 大写字母 W |
88 | 130 | 58 | 01011000 | X | X | 大写字母 X |
89 | 131 | 59 | 01011001 | Y | Y | 大写字母 Y |
90 | 132 | 5A | 01011010 | Z | Z | 大写字母 Z |
91 | 133 | 5B | 01011011 | [ | [ | 左中括号 |
92 | 134 | 5C | 01011100 | \ | \ | 反斜杠 |
93 | 135 | 5D | 01011101 | ] | ] | 右中括号 |
94 | 136 | 5E | 01011110 | ^ | ^ | 音调符号 |
95 | 137 | 5F | 01011111 | _ | _ | 下划线 |
96 | 140 | 60 | 01100000 | ` | ` | 重音符 |
97 | 141 | 61 | 01100001 | a | a | 小写字母 a |
98 | 142 | 62 | 01100010 | b | b | 小写字母 b |
99 | 143 | 63 | 01100011 | c | c | 小写字母 c |
100 | 144 | 64 | 01100100 | d | d | 小写字母 d |
101 | 145 | 65 | 01100101 | e | e | 小写字母 e |
102 | 146 | 66 | 01100110 | f | f | 小写字母 f |
103 | 147 | 67 | 01100111 | g | g | 小写字母 g |
104 | 150 | 68 | 01101000 | h | h | 小写字母 h |
105 | 151 | 69 | 01101001 | i | i | 小写字母 i |
106 | 152 | 6A | 01101010 | j | j | 小写字母 j |
107 | 153 | 6B | 01101011 | k | k | 小写字母 k |
108 | 154 | 6C | 01101100 | l | l | 小写字母 l |
109 | 155 | 6D | 01101101 | m | m | 小写字母 m |
110 | 156 | 6E | 01101110 | n | n | 小写字母 n |
111 | 157 | 6F | 01101111 | o | o | 小写字母 o |
112 | 160 | 70 | 01110000 | p | p | 小写字母 p |
113 | 161 | 71 | 01110001 | q | q | 小写字母 q |
114 | 162 | 72 | 01110010 | r | r | 小写字母 r |
115 | 163 | 73 | 01110011 | s | s | 小写字母 s |
116 | 164 | 74 | 01110100 | t | t | 小写字母 t |
117 | 165 | 75 | 01110101 | u | u | 小写字母 u |
118 | 166 | 76 | 01110110 | v | v | 小写字母 v |
119 | 167 | 77 | 01110111 | w | w | 小写字母 w |
120 | 170 | 78 | 01111000 | x | x | 小写字母 x |
121 | 171 | 79 | 01111001 | y | y | 小写字母 y |
122 | 172 | 7A | 01111010 | z | z | 小写字母 z |
123 | 173 | 7B | 01111011 | { | { | 左大括号 |
124 | 174 | 7C | 01111100 | | | | | 垂直线 |
125 | 175 | 7D | 01111101 | } | } | 右大括号 |
126 | 176 | 7E | 01111110 | ~ | ~ | 波浪号 |
127 | 177 | 7F | 01111111 | � | 删除 |
扩展ASCII码
后128个称为扩展ASCII码。许多基于x86的系统都支持使用扩展(或“高”)ASCII。扩展ASCII码允许将每个字符的第8 位用于确定附加的128 个特殊符号字符、外来语字母和图形符号
十进制DEC | 八进制OCT | 十六进制HEX | 二进制BIN | 符号Symbol | HTML实体编码 | 中文解释Description |
128 | 200 | 80 | 10000000 | € | � | 欧盟符号 |
129 | 201 | 81 | 10000001 | |||
130 | 202 | 82 | 10000010 | ‚ | � | 单低 9 引号 |
131 | 203 | 83 | 10000011 | ƒ | � | 带钩的拉丁小写字母f |
132 | 204 | 84 | 10000100 | „ | � | 双低 9 引号 |
133 | 205 | 85 | 10000101 | … | � | 水平省略号 |
134 | 206 | 86 | 10000110 | † | � | 剑号 |
135 | 207 | 87 | 10000111 | ‡ | � | 双剑号 |
136 | 210 | 88 | 10001000 | ˆ | � | 修正字符抑扬音符号 |
137 | 211 | 89 | 10001001 | ‰ | � | 千分号 |
138 | 212 | 8A | 10001010 | Š | � | 带弯音号的拉丁大写字母 S |
139 | 213 | 8B | 10001011 | ‹ | � | 左单书名号 |
140 | 214 | 8C | 10001100 | Œ | � | 拉丁大写组合 OE |
141 | 215 | 8D | 10001101 | |||
142 | 216 | 8E | 10001110 | Ž | � | 带弯音号的拉丁大写字母 z |
143 | 217 | 8F | 10001111 | |||
144 | 220 | 90 | 10010000 | |||
145 | 221 | 91 | 10010001 | ‘ | � | 左单引号 |
146 | 222 | 92 | 10010010 | ’ | � | 右单引号 |
147 | 223 | 93 | 10010011 | “ | � | 左双引号 |
148 | 224 | 94 | 10010100 | ” | � | 右双引号 |
149 | 225 | 95 | 10010101 | • | � | |
150 | 226 | 96 | 10010110 | – | � | 半长破折号 |
151 | 227 | 97 | 10010111 | — | � | 全长破折号 |
152 | 230 | 98 | 10011000 | ˜ | � | 小波浪线 |
153 | 231 | 99 | 10011001 | ™ | � | |
154 | 232 | 9A | 10011010 | š | � | 带弯音号的拉丁小写字母 s |
155 | 233 | 9B | 10011011 | › | � | 右单书名号 |
156 | 234 | 9C | 10011100 | œ | � | 拉丁小写组合 oe |
157 | 235 | 9D | 10011101 | |||
158 | 236 | 9E | 10011110 | ž | � | 带弯音号的拉丁小写字母 z |
159 | 237 | 9F | 10011111 | Ÿ | � | 带弯音号的拉丁大写字母 Y |
160 | 240 | A0 | 10100000 | |||
161 | 241 | A1 | 10100001 | ¡ | ¡ | 反向感叹号 |
162 | 242 | A2 | 10100010 | ¢ | ¢ | 分币符号 |
163 | 243 | A3 | 10100011 | £ | £ | 英磅符号 |
164 | 244 | A4 | 10100100 | ¤ | ¤ | |
165 | 245 | A5 | 10100101 | ¥ | ¥ | 人民币符号 |
166 | 246 | A6 | 10100110 | ¦ | ¦ | |
167 | 247 | A7 | 10100111 | § | § | 章节符号 |
168 | 250 | A8 | 10101000 | ¨ | ¨ | 通用货币符号 |
169 | 251 | A9 | 10101001 | © | © | 版权符号 |
170 | 252 | AA | 10101010 | ª | ª | 阴性顺序指示符号 |
171 | 253 | AB | 10101011 | « | « | 左角引号 |
172 | 254 | AC | 10101100 | ¬ | ¬ | |
173 | 255 | AD | 10101101 | | | |
174 | 256 | AE | 10101110 | ® | ® | |
175 | 257 | AF | 10101111 | ¯ | ¯ | |
176 | 260 | B0 | 10110000 | ° | ° | 温度符号 |
177 | 261 | B1 | 10110001 | ± | ± | 加/减号 |
178 | 262 | B2 | 10110010 | ² | ² | 上标 2 |
179 | 263 | B3 | 10110011 | ³ | ³ | 上标 3 |
180 | 264 | B4 | 10110100 | ´ | ´ | |
181 | 265 | B5 | 10110101 | µ | µ | 微符号 |
182 | 266 | B6 | 10110110 | ¶ | ¶ | 段落符号,pilcrow |
183 | 267 | B7 | 10110111 | · | · | 中点 |
184 | 270 | B8 | 10111000 | ¸ | ¸ | |
185 | 271 | B9 | 10111001 | ¹ | ¹ | 上标 1 |
186 | 272 | BA | 10111010 | º | º | 阳性顺序指示符 |
187 | 273 | BB | 10111011 | » | » | 右角引号 |
188 | 274 | BC | 10111100 | ¼ | ¼ | 分数四分之一 |
189 | 275 | BD | 10111101 | ½ | ½ | 分数二分之一 |
190 | 276 | BE | 10111110 | ¾ | ¾ | |
191 | 277 | BF | 10111111 | ¿ | ¿ | 反向问号 |
192 | 300 | C0 | 11000000 | À | À | 带重音符的大写字母 A |
193 | 301 | C1 | 11000001 | Á | Á | 带尖锐重音的大写字母 A |
194 | 302 | C2 | 11000010 | Â | Â | 带音调符号的大写字母 A |
195 | 303 | C3 | 11000011 | Ã | Ã | 带代字号的大写字母 A |
196 | 304 | C4 | 11000100 | Ä | Ä | 带元音变音(分音符号)的大写字母 A |
197 | 305 | C5 | 11000101 | Å | Å | 带铃声的大写字母 A |
198 | 306 | C6 | 11000110 | Æ | Æ | 大写字母 AE双重元音 |
199 | 307 | C7 | 11000111 | Ç | Ç | 带变音符号的大写字母 C |
200 | 310 | C8 | 11001000 | È | È | 带重音符的大写字母 E |
201 | 311 | C9 | 11001001 | É | É | 带尖锐重音的大写字母 E |
202 | 312 | CA | 11001010 | Ê | Ê | 带音调符号的大写字母 E |
203 | 313 | CB | 11001011 | Ë | Ë | 带元音变音(分音符号)的大写字母 E |
204 | 314 | CC | 11001100 | Ì | Ì | 带重音符的大写字母 I |
205 | 315 | CD | 11001101 | Í | Í | 带尖锐重音的大写字母 I |
206 | 316 | CE | 11001110 | Î | Î | 带音调符号的大写字母 I |
207 | 317 | CF | 11001111 | Ï | Ï | 带元音变音(分音符号)的大写字母 I |
208 | 320 | D0 | 11010000 | Ð | Ð | |
209 | 321 | D1 | 11010001 | Ñ | Ñ | 带代字号的大写字母 N |
210 | 322 | D2 | 11010010 | Ò | Ò | 带重音符的大写字母 O |
211 | 323 | D3 | 11010011 | Ó | Ó | 带尖锐重音的大写字母 O |
212 | 324 | D4 | 11010100 | Ô | Ô | 带音调符号的大写字母 O |
213 | 325 | D5 | 11010101 | Õ | Õ | 带代字号的大写字母 O |
214 | 326 | D6 | 11010110 | Ö | Ö | 带元音变音(分音符号)的大写字母 O |
215 | 327 | D7 | 11010111 | × | × | 大写字母OE 连字 |
216 | 330 | D8 | 11011000 | Ø | Ø | 带斜杠的大写字母 O |
217 | 331 | D9 | 11011001 | Ù | Ù | 带重音符的大写字母 U |
218 | 332 | DA | 11011010 | Ú | Ú | 带尖锐重音的大写字母 U |
219 | 333 | DB | 11011011 | Û | Û | 带音调符号的大写字母 U |
220 | 334 | DC | 11011100 | Ü | Ü | 带元音变音(分音符号)的大写字母 U |
221 | 335 | DD | 11011101 | Ý | Ý | 带元音变音(分音符号)的大写字母 Y |
222 | 336 | DE | 11011110 | Þ | Þ | |
223 | 337 | DF | 11011111 | ß | ß | 德语高调小写字母 s |
224 | 340 | E0 | 11100000 | à | à | 带重音符的小写字母 a |
225 | 341 | E1 | 11100001 | á | á | 带尖锐重音的小写字母 a |
226 | 342 | E2 | 11100010 | â | â | 带音调符号的小写字母 a |
227 | 343 | E3 | 11100011 | ã | ã | 带代字号的小写字母 a |
228 | 344 | E4 | 11100100 | ä | ä | 带元音变音(分音符号)的小写字母 a |
229 | 345 | E5 | 11100101 | å | å | 带铃声的小写字母 a |
230 | 346 | E6 | 11100110 | æ | æ | 小写字母 ae双重元音 |
231 | 347 | E7 | 11100111 | ç | ç | 带变音符号的小写字母 c |
232 | 350 | E8 | 11101000 | è | è | 带重音符的小写字母 e |
233 | 351 | E9 | 11101001 | é | é | 带尖锐重音的小写字母 e |
234 | 352 | EA | 11101010 | ê | ê | 带音调符号的小写字母 e |
235 | 353 | EB | 11101011 | ë | ë | 带元音变音(分音符号)的小写字母 e |
236 | 354 | EC | 11101100 | ì | ì | 带重音符的小写字母 i |
237 | 355 | ED | 11101101 | í | í | 带尖锐重音的小写字母 i |
238 | 356 | EE | 11101110 | î | î | 带音调符号的小写字母 i |
239 | 357 | EF | 11101111 | ï | ï | 带元音变音(分音符号)的小写字母 i |
240 | 360 | F0 | 11110000 | ð | ð | |
241 | 361 | F1 | 11110001 | ñ | ñ | 带代字号的小写字母 n |
242 | 362 | F2 | 11110010 | ò | ò | 带重音符的小写字母 o |
243 | 363 | F3 | 11110011 | ó | ó | 带尖锐重音的小写字母 o |
244 | 364 | F4 | 11110100 | ô | ô | 带音调符号的小写字母 o |
245 | 365 | F5 | 11110101 | õ | õ | 带代字号的小写字母 o |
246 | 366 | F6 | 11110110 | ö | ö | 带元音变音(分音符号)的小写字母 o |
247 | 367 | F7 | 11110111 | ÷ | ÷ | 小写字母 oe连字 |
248 | 370 | F8 | 11111000 | ø | ø | 带斜杠的小写字母 o |
249 | 371 | F9 | 11111001 | ù | ù | 带重音符的小写字母 u |
250 | 372 | FA | 11111010 | ú | ú | 带尖锐重音的小写字母 u |
251 | 373 | FB | 11111011 | û | û | 带音调符号的小写字母 u |
252 | 374 | FC | 11111100 | ü | ü | 带元音变音(分音符号)的小写字母 u |
253 | 375 | FD | 11111101 | ý | ý | 带元音变音(分音符号)的小写字母 y2 |
254 | 376 | FE | 11111110 | þ | þ | |
255 | 377 | FF | 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 | 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)))
-------------------------------------------
个性签名:独学而无友,则孤陋而寡闻。做一个灵魂有趣的人!
如果觉得这篇文章对你有小小的帮助的话,记得在右下角点个“推荐”哦,博主在此感谢!
万水千山总是情,打赏一分行不行,所以如果你心情还比较高兴,也是可以扫码打赏博主,哈哈哈(っ•̀ω•́)っ✎⁾⁾!
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· DeepSeek “源神”启动!「GitHub 热点速览」
· 我与微信审核的“相爱相杀”看个人小程序副业
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· C# 集成 DeepSeek 模型实现 AI 私有化(本地部署与 API 调用教程)
· spring官宣接入deepseek,真的太香了~