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) # 相等吗?

问题:

  1. 最终a 和 b相等吗?a和b分别存着什么元素
  2. 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 &#087 大写字母 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 ÿ ÿ

重点

  1. \x00是ASCII表中第一项,C语言中的字符串结束符
  2. \t、\x09,表示tab字符
  3. \r\n是\x0d\x0a
  4. \x30~\x39 字符0~9,\x31是字符1
  5. \x41对应十进制65,表示A
  6. \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)))

posted on   无语至极  阅读(295)  评论(0编辑  收藏  举报

相关博文:
阅读排行:
· DeepSeek “源神”启动!「GitHub 热点速览」
· 我与微信审核的“相爱相杀”看个人小程序副业
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· C# 集成 DeepSeek 模型实现 AI 私有化(本地部署与 API 调用教程)
· spring官宣接入deepseek,真的太香了~

导航

< 2025年2月 >
26 27 28 29 30 31 1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 1
2 3 4 5 6 7 8
点击右上角即可分享
微信分享提示