目录

第一章

  • 行连接符
  • 对象
  • 变量
  • 赋值
  • 运算符
  • 进制
  • 字符截取

第二章

  • 列表
  • 元组
  • 字典

附页

  • 函数
  • 方法
  • 模块

行连接符：\

  • 作用：一行代码太长时，换行写要用 ’ \ ‘。
a = 'abcdef\
ghigklmn\
opqrst'
print(a)
输出：abcdefghigklmnopqrst

对象：标签，类型，值

a = 6
'''
创建了一个
	标签：xxxxx
	类型：int
	值：6
的内存块
a是一个指向该内存块标签的变量。
'''
  • 变量位于：栈内存
  • 对象位于：堆内存

删除变量与垃圾回收：del

a = 123
del a
#变量a被压出栈，变量a所对应堆中的对象会被垃圾回收。

链式、系列解包赋值

a = b = 123
#相当于：a=123;b=123
#将对象123的标签赋值给a和b

a,b,c = 1,2,3
#相当于:a=1,b=2,c=3

a,b = b,a
#相当于把a,b的值互换

常量：python不支持常量，逻辑上将全大写变量视为常量。

运算符：

  • 整除：’ // ‘ ：做除法，舍去余数
  • 增强型：+= ，-= , /= , //= 等等…
a += 1
a -= 1
#相当于:a=a+1、a=a-1
  • **同一运算符：**is
a = 3
b = 3
a is b
#输出：true
#同一运算符用来比较两个对象的存储单元地址（id）是否一致
  • 相等运算符：==
a = 3
b = 3
a == b
#输出true
#相当运算符判断两个对象的值（value）是否一致
  • **整数缓存问题：**python命令行下会对较小的整数【-5~256】进行缓存。
a = 1000
b = 1000
a is b
#输出false，原因是整数1000>256，python会为其创建一个新的内存块
a = 3
b = 3
a is b
#输出true，原因是整数3<256，python会缓存该内存块，并且直接使用

在文件下，解释器会优化该部分，【-5~任意正整数】都会被缓存

  • **字符串驻留：**类似于整数缓存，python对符合标识符规则的字符串（下划线，字母，数字）会启用字符串驻留机制。
a = 'abc_d'
b = 'abc_d'
a is b
#输出true，原因是 a 创建的内存块被python驻留，而 b 直接赋值了该驻留的块的id，而并没有创建新的块。
  • 成员操作符：in、not in 用来判断 某个子字符是否存在于字符串中。
a = 'abc'
b = 'a'
b in a
#输出：true 很显然 b 中的值是 a 值的成员（一部分）
  • 位移：>>右移（除2）、<<左移（乘2）
  • 位运算符：^ 异或、| 或、& 与

函数：

  • divmod( ):得到商和余数
divmod(13,3)
返回：(4,1)
  • int( ):将小数取整、将布尔转换为 ’ 0 , 1 ‘ 、将字符串转换为数值型（必须符合数值类型）
  • float( ):同int( ),转为浮点型
  • str( ):同int( ),转为字符串型
  • print(‘字符’,end=’默认换行符‘)：end=’任意字符‘，修改’任意字符‘print( )结尾就不是换行符了。
  • input(‘提示字符’)：接受用户的输入。
  • list(‘数据’)：将任何可迭代的数据转化成为列表
a = list(range(10))
b = list("abcdef")
#输出：[0,1,2,3,4,5,6,7,8,9]，['a','b','c','d','e','f']

进制：

  • 0b：二进制
  • 0o：八进制
  • 0x：十六进制

字符提取：[]

a = 'abcdefg'
print(a[0])
print(a[-1])
#输出：a，g
#用来截取单个字符，索引起始为0，截止为len（a）-1
  • 切片：[起始:结束:步长] 用于快速的提取字符
a = 'abcd'
print(a[1:4])
#输出：‘abc’ 这体现了切片’包头 不包尾‘的特性
print(a[1:5:1])
print(a[1:5:2])
#输出：’abcd‘ ’ac‘ 步长是指，一次处理n个字符，并提取第一个
#很明显，步长为1，处理了所有的字符；步长为2，处理了’ab‘，提取了'a'
#处理了’cd‘，提取了’c‘

方法：

  • ***x.replace(’ a '，’ b ‘ )***： 将 x 中的字符’ a ‘替换为’ b ‘
  • 该方法不会改变原来 x 的值，而是创建一个新的对象。
  • **x.split( ’ 分隔符 ’ )：**将 x 中的字符 按照 ’ 分割符 ‘ 进行分割成列表。
  • “连接符”.join( x ): 将 x 中的字符系列[列表] 用’ 连接符 ‘连接起来。
a = ['text','val','ten']
'@'.join(a)
#输出：text@val@ten
#join性能优于 ’ + ‘ ，因为字符是不可变的，但列表是可变的
  • 查找方法：
  • len（a）：返回字符串长度【中英同等地位】
  • x.startswith（’字符串‘）：返回 x 是否以 ’ 字符串 ‘ 作为开头
  • x.endswith（‘字符串’）：返回 x 是否以 ‘字符串’ 作为结尾
  • x.find（‘字符串’）：返回 ‘ 字符串 ’ 在 x 中第一次出现的位置
  • x.rfind（‘字符串’）：返回‘ 字符串 ’ 在 x 中最后一次出现的位置
  • x.count（‘字符串’）：返回‘ 字符串 ‘ 在 x 中出现了几次

【判断方法】：

  • x.isalnum（ ）：返回 x 中的值是否全部为数字或者字母
  • x.isspace（ ）：返回 x 中的值是否全部为空白符
  • x.isdigit（ ）：返回 x 中的值是否全部为数字
  • x.isalpha（ ）：返回 x 中的值是否全为字母或汉字
  • 去除首尾信息：
  • x.strip（’字符‘）：去除 x 首尾的字符，默认是空格
  • x.lstrip（’字符‘）：去除 x 首部的字符，默认是空格
  • x.rstrip（’字符‘）：去除 x 尾部的字符，默认是空格
  • 格式排版：
  • x.center（’长度‘，’补齐‘）：将 x 的值居中，两头根据指定长度用’ 补齐 ‘来填充，默认用空格填充。
  • x.rjust（’长度‘，’补齐‘）：同center（ ），右对齐。
  • x.ljust（’长度‘，’补齐‘）：同center（ ），左对齐。
  • x.format（ ）：接受 n 个参数替换 x 中的占位符{ }
  • 占位符 {索引/参数名}：代替了原来的%
  • 用来代替不确定的值，当调用format时，format的参数替换该占位符
a = 'yes i am {0},i like {1}'
a.format('zlx','apple')
#输出：'yes i am zle,i like apple' 使用索引占位符时要注意顺序，0就是format参数中的第一个值，依次...

a = 'yes i am {name},i like {thing}'
a.format(name='zlx',thing='apple')
#输出：'yes i am zle,i like apple' 使用参数名占位符不需要注意顺序，只要名称对应即可。
  • 占位符用法：
  • {索引/参数名 (😃 (填充字符) (<,左对齐,>右对齐,^居中) (长度) (类型f,d,e,%) }
{:*^8}.format('yes')
#输出：**yes*** 长度为8，填充字符为*，居中对齐，替换字符为’yes‘

列表：

  • 列表的创建：
  • list（）创建
  • 推导式创建：[「表达式」 「for 变量 in 列表」『 if x == 条件』]
  • 列表的增加与删除：
  • 增加
  • x.append(元素)：在列表尾部增加
  • x=x+[元素]：创建新列表，替换原来的列表，并不是简单的添加。
  • x.extend([列表])：将目标列表的元素添加到本列表尾部。
a = [1,2,3]
a.append([4,5])
#输出：[1,2,3,[4,5]]直接将[4，5]列表添加到了尾部
a.extend([6,7])
#输出：[1,2,3,[4,5],6,7]将两个列表合并成了一个
  • 插入：
  • x.insert（索引,元素）：将元素插入 x 指定索引处
  • 删除：
  • del x[索引]：将指定索引的元素删除
  • x.pop (n)：将指定索引的元素删除，并返回值，未指定默认弹出最后一个元素。
  • x.remove (值):删除首次出现的值，如果没有则提示异常
  • 获得：
  • x.index (值,start,end)：返回 指定值在列表中 首次出现的索引。start和end指定了搜索的范围。
  • 排序：
  • x.sort(reverse=True):对列表进行修改排序，默认升序。
  • 函数sorted(x,reverse=True)：创建的已排序列表，不改变原来的列表。
  • 函数reversed(x):返回一个逆序迭代器，可以用list（迭代器）创建一个逆序列表。迭代器只能使用一次。
  • 数学函数：
  • max( x )：返回列表中的最大值
  • min( x )：返回列表中的最小值
  • sum( x ):对数值型列表进行求和
  • 多维列表：
a = [
  ['搞笑二',18,3000,'上海'],
  ['找小三',19,4000,'北京'],
  ['王麻子',20,2000,'深圳']
]
a[0]
#输出：['搞笑二',18,3000,'上海']
a[0][2]
#输出：3000，a的第一个元素列表中 的第二个元素。

元组：

  • 元组属于不可变序列，不能修改元组中的元素。
  • 元组的创建：
  • tuple（可迭代对象）
  • x = （元素1，元素2…）
  • x = 元素1，元素2，元素3，…
  • 注意：单个元素这样写 x = (20,) 否则解释器会认为是整数类型不是元组。
  • 访问：x [索引] 或 x [切片]
  • 合成：
  • 连字符 ‘ + ’ ：将两个元组合并
  • 函数zip(列表1，列表2，列表3…)
a = [1,2,3]
b = [4,5,6]
c = [7,8,9]
d = zip(a,b,c)
list(d)
#输出：[(1,2,3),(4,5,6),(7,8,9)]
#该函数将 多个列表 转换为 等量元组 并合并起来，返回这个对象。
  • 生成器：s = ([表达式] [for 变量 in 数据] [if 条件])
  • s.__next__()：用来将生成器中的值一个个取出。
  • 注意：生成器实际上就是一个内存块指针，每次取值，指针会向后移动，直到生成器尾部。移动后的生成器不可复原，因此生成器是一次性的。

字典：

  • 字典的创建：
  • a = { ’ 键 ’ ：’ 值 ’ ，…}：键是任意 不可改变 的数据，如：整数，浮点数字符串，元组。且键是 不可重复 的！
  • **函数dict（键=值,…）**或 dict（ [ (键，值)，(键，值) ] ）
  • 函数zip（列表1，列表2）：zip函数将 列表1 和 列表2 打包起来，在用dict（）转换为字典时时，列表1 作为字典键，列表2 作为字典的值。
a = ['car','color','food']
b = ['bus','red','apple']
c = zip(a,b)#将 a ，b 打包为新的对象 赋值给c
dict(c)#将 c 转换为字典，其中 a 作为键， b 作为值
  • Dict.fromkeys([键1，键2，键3，…])：创建空值的字典
  • 字典的访问：
  • a.[键]：访问值，键不存在返回错误❌
  • a.get[‘键’，‘默认值‘]：推荐使用。可以访问不存在的键，返回NONE。也可以为其制定 默认值 ，如果 键 不存在则返回默认值。
  • a.items():列出所有的 键和值。
  • a.keys():列出所有的键。
  • a.values():列出所有的值。
  • 字典的 修改 添加 删除
  • 添加：
  • a[键] = ‘值’
  • a.update(字典)：将新字典的所有 键值 添加到 a 中，键重复的直接覆盖。
  • 删除：
  • del（ a[键] ）
  • clear（字典）：删除所有的 键值对
  • a.pop（键）：弹出指定的 键值对
  • a.popitem():随机弹出 键值对
  • 序列解析包：方便的给多个变量赋值
s = ['name':'zlx','age':19,'job':'student']
a,b,c=s
#这里将s的 键 赋值给了a,b,c
a,b,c=s.values()
#这里将s的 值 赋值给了a,b,c
a,b,c=s.items()
#这里将s的 键值对 赋值给了a,b,c

模块：

  • time:时间模块
  • io：可变字符串
  • s=io.StingIO(x):将可变字符串 x 的id赋值给s
  • s.getvalue( ):获得 s 的值
  • s.seek(n):指向 s 值的第n个字符
  • s.write(‘字符’):修改当前指向的值
  • turtle：海龟绘图
  • random：乱序
  • random.shuffle(x)：列表 x 的元素打乱顺序。