简介

这篇文章我打算用来记录一些python中常常会用到的或者个人感觉有用知识点，当个备忘录

python保留字

截至python3.9.1，python的保留字有36个，保留字的含义及作用如下图所示：

序号 保留字 作用
1 raise 引发异常,且可指定异常时打印的文本
2 assert 用于判断变量或条件表达式的结果
3 yield 相当于return,用于返回一次性的序列值或变量值
4 _peg_parser_ 未知,以后再写
5 None 表示一个空对象或是一个特殊的空值
6 True 含义为“真”的逻辑值
7 False 含义为“假”的逻辑值
8 and 逻辑与操作，用于表达式运算
9 as 将函数或表达式封装成一个指定的字面量
10 async 未知,以后再写
11 await 未知,以后再写
12 class 定义类
13 continue 继续执行下一次循环
14 def 定义函数或方法
15 del 删除变量或者序列的值
16 elif 条件语句
17 else 条件语句
18 except 捕捉异常后的处理代码块,通常与try连用
19 finally 包含捕获异常后的始终要调用的代码块，与 try、except 结合使用
20 for 循环语句
21 from 用于导入模块，与 import 结合使用
22 global 用于在函数或其他局部作用域中声明全局变量
23 if 判断语句
24 import 用于导入模块
25 in 判断变量是否在序列中
26 is 判断变量是否为某个类的实例
27 lambda 定义匿名函数
28 nonlocal 未知,以后再写
29 not 逻辑非操作，用于表达式运算
30 or 逻辑或操作，用于表达式运算
31 pass 空的类、方法或函数的占位符
32 return 从函数返回结果
33 try 测试执行可能出现异常的代码，与 except, finally 结合使用
34 while 循环语句
35 with 简化 Python 的语句
36 break 中断循环语句的执行

raise

raise关键字用来引发异常，可以指定异常时打印给用户的文本
当raise关键字引发异常后，后面的代码将停止执行

1
2
3
4
5
6
实例：
x = '1'
if not type(x) is int:
  raise TypeError("x的类型不是整形")
print('Hello')

Traceback (most recent call last):
File “C:\Users\Jason\Desktop\test.py”, line 7, in
raise TypeError(“x的类型不是整形”)
TypeError: x的类型不是整形

raise的一般用法

一般用于加判定条件，指定引发的异常，从而使代码达到自己想要的效果
可以与python的其他模块搭配使用，例如retrying

1
2
3
4
5
6
7
8
9
10
实例：
import random
def randnum():
    num = random.randint(0,50)
    print(num)
    if num < 50:
        raise Exception("这不是我想要的数") #如果生成的数小于50，则引发异常
    print('Hello')
    return num
print("success",randnum())

assert

这个保留字与上面说的raise有着异曲同工之妙，同样是指定引发异常，也可以指定异常时打印的文本
assert和raise一样，通常与retrying等模块搭配使用

1
2
3
4
5
6
7
8
语法格式：
    assert [变量或表达式],[异常时打印的文本,字符串类型]

实例：
assert 1 == 1
等同于
if not 1 == 1:
    raise

yield

学习yield之前建议先了解迭代器与生成器
yield保留字相当于return，区别在于yield返回的是一个生成器，return返回的是一个迭代器

1
2
3
4
5
6
7
8
9
例子：
def main():
    for i in range(3):
        yield i
result = main()
for i in result:
    print(i)
for i in result:    只能调用一次，第二次调用没有返回值
    print(i)

迭代器与生成器

提示：代码执行结果自己试或者自行想象，懒得放出来了，反正没人看

迭代器

创建一个列表，你可以逐个读取它的项，逐个读取它的项的过程称为迭代
列表的值是永久储存在内存里的，当列表有很多值或者我们只需调用其少数时，这种做法就比较浪费内存且影响性能

1
2
3
4
例如：
li = [ x for x in range(5) ]
for i in li:
    print(i)

生成器

生成器(generator)
生成器也是迭代器，不过生成器只会迭代一次，说简单点就是只能调用一次，不能调用第二次
它们会动态生成这些值而不会将所有者都储存在内存中
它的列表解析式和迭代器类似，不过用 ( ) 替代了 [ ] 

1
2
3
4
5
6
例如：
li = ( x for x in range(5) )
for i in li:
    print(i)
for i in li:
    print(i)    只能调用一次，第二次调用没有返回值

三目运算符

语法格式：
true_command if 条件表达式 else false_command
如果条件表达式成立执行true_command的代码，不成立则执行false_command的代码

1
2
3
4
举个栗子，使用三目运算符判断两个输入的数的关系:
first_number = int(input('Please enter your first_number：'))
second_number = int(input('Please enter your second_number：'))
print("Max number is first_number：%d " % first_number) if first_number > second_number else print("Max number is second_number：%d " % second_number)

切片

切片的一般使用方法为：
listname[start:end:step]
start为起始索引，就是你想从列表中从左往右第几个元表开始取值(通常与end搭配划定取值范围)
end为结束索引，就是你想从列表中从左往右第几个元素结束取值
step为步长，就是每一次遍历的元素间隔(默认从列表的左往右开始遍历，若为负数，则从右往左开始遍历)

1
2
3
举个栗子，用切片方法将列表中的元素倒序：
a = [1,2,3,4,5,6,7,8]
print(a[::-1])

屏幕输出：[8, 7, 6, 5, 4, 3, 2, 1]

常见列表方法

以下方法用于列表操作

列表追加元素

append()

append()追加元素，若元素为列表或元组，整个列表/元组也被当成一个整体追加到列表

1
2
3
4
5
举个栗子：
l = ['Jason']
l.append(['Ruby', 'SQL'])
l.append(('Amy','Wanghua'))
print(l)

屏幕输出：[‘Jason’, [‘Ruby’, ‘SQL’], (‘Amy’, ‘Wanghua’)]

extend()

extend()追加元素，与append的区别就是：extend不会把列表/元组当成一个元素，而是会将列表/元组所包含的元素逐个追加到列表中

1
2
3
4
5
举个栗子：
l = ['Jason']
l.extend(['Ruby','SQL'])
l.extend(('Amy','Wanghua'))
print(l)

屏幕输出：[‘Jason’, ‘Ruby’, ‘SQL’, ‘Amy’, ‘Wanghua’]

删除列表元素

pop()

pop()：根据索引值删除元素
pop() 方法用来删除列表中指定索引处的元素，如果index不指定，默认会删除列表中的最后一个元素

1
2
3
4
5
6
7
8
9
10
语法格式：
    listname.pop(index)

举个栗子：
l = ['Python', 'C++', 'Java']
j = ['Python', 'C++', 'Java']
l.pop()
print(l)
j.pop(1)
print(j)

[‘Python’, ‘C++’]
[‘Python’, ‘Java’]

clear()

clear()：删除列表所有元素
clear() 用来删除列表的所有元素，即清空列表里面的所有值，请看下面的代码：

1
2
3
i = ['Python', 'C++', 'Java']
i.clear()
print(i)

屏幕输出：[]

一组元素赋值

切片的基本操作

通过切片语法给一组元素赋值，但是如果用此语法给元素赋单个值会报错
并且如果使用字符串赋值，Python 会自动把字符串转换成序列，其中的每个字符都是一个元素

1
2
3
4
5
6
7
8
举个栗子：
i = [1,2,3,4,5]
i[1:4] = 6,7,8,9
print(i)

a = [1,2,3,4,5]
a[1:4] = "Hello"
print(a)

屏幕输出：[1, 6, 7, 8, 9, 5]
屏幕输出：[1, ‘H’, ‘e’, ‘l’, ‘l’, ‘o’, ‘l’, 9, 5]

切片的高阶用法

使用切片语法时也可以指定步长（step 参数），但这个时候就要求所赋值的新元素的个数与原有元素的个数相同，例如：

1
2
3
4
举个栗子，给列表里的第1、3、5个元素赋值：
nums = [40, 36, 89, 2, 36, 100, 7]
nums[1: 6: 2] = [0.025, -99, 20.5]  #步长为2，为第1、3、5个元素赋值
print(nums)

屏幕输出：[40, 0.025, 89, -99, 36, 20.5, 7]

查找元素

index()

index()用来查找指定元素在列表中出现的位置，如果该元素不存在，则会导致 ValueError 错误，所以在查找之前最好使用 count() 方法判断一下

1
2
3
4
5
6
7
8
9
语法格式：    
    listname.index(obj, start, end)
obj表示需要查找的元素名，start和end可不写，此时会检索整个列表

举个栗子，查找数字3否在列表里：

i = [0,1,2,3,4,5,6,7,8,9]
a = i.index(3)
print(a)

屏幕输出：3

count()

count()方法用来统计某个元素在列表中出现的次数，如果 count() 返回 0，就表示列表中不存在该元素，所以 count() 也可以用来判断列表中的某个元素是否存在

1
2
3
4
5
6
7
8
9
10
基本语法格式为：
    listname.count(obj)
listname 代表列表名，obj 表示要统计的元素,

举个栗子：

i = [0,1,2,3,4,5,6,7,8,9]
a = i.count(10)
b = i.count(1)
print(a,b)

屏幕输出：0 1