1
2
3
4
5
6
# 定义一个变量m来接受来自控制台的信息
m = input("输入你想输入的内容：")
print("输出你输入的内容：" + m)
n = int(input("输入你想输入的内容："))
print("输出你输入的内容：" + n)

1
2
3
4
5
6
7
8
9
# code
print("2"+"5") #两个包含数字的字符串连接
print("2"+1)
# 一个包含数字的字符串和数字进行连接
# output 
25
"TypeError: can only concatenate str (not "int") to str"
# 类型错误 只能连接str(不是“int”)到str

1
2
3
4
5
6
7
8
print("happy" * 3)
# happyhappyhappy
# 常见的错误
print('happy' * '2')
# can't multiply sequence by non-int of type 'str'
print('python' * 7.0)
# can't multiply sequence by non-int of type 'float'

1
2
3
4
5
print("4" + "5")
# 字符的相加 (连接)
print(int("4") + int("5"))
# 把字符类型强转为int类型

1
2
3
4
5
6
7
8
c = 'python'
del c
# print(c)
# NameError: name 'c' is not defined 变量c的值没有定义
c = 'python3.0'
print(c)
# python3.0

1
2
3
4
# 单行注释
" 多行注释"
'多行注释'

1
2
3
4
5
6
7
8
m = 20
if m == 20:
# 赋值和等于要分清 冒号代表缩进开始
print(m)
else:
print(m + 1)
# 缩进一致(语句)

1
2
3
4
5
6
7
m = 20
if m == 20:
print("m不等于20")
if m == 10:
print("m不等于10")
# 缩进一致(语句) 没有缩进代表并列if语句

1
2
3
4
5
6
7
8
m = 20
if m == 20:
print("m等于20")
elif m == 10:
print("等于10")
elif m == 5:
print("等于5")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
print(4 == 4 and 6 == 6)
print(1 == 2 and 2 == 2)
print(8 == 8 and 45 == 35)
print(1 == 3 or 2 == 5)
print(1 == 1 or 2 == 5)
print(1 == 1 or 2 == 2)
print(1 == 1 or 2 == 2)
print(1 == 1 or not 2 == 2)
print(not 1 == 1 or 2 == 2)
# True
# False
# False
# False
# True
# True
# True
# True
# Ture

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
while m <= 10:
print(m + 1)
m = m + 1
print("完成")
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9
# 10
# 11
# 完成
在这里插入代码片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
data = ["hello", "world", "!"]
# data 是一个list列表
# 列表中的某个项目可以通过方括号（[])中的索引进行访问 。
print(data[0])
print(data[1])
print(data[2])
# []创建空列表
支持嵌套
溢出
things = ["strings", 0, [2, 3, 'numbers'], 5.60]
print(things)
# hello
# world
# !
# ['strings', 0, [2, 3, 'numbers'], 5.6]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
print(data + [5, 5.6])
print(data * 5)
# 在这里里可以把list看做字符串
# 这里是对字符串的基本操作
# 字符串被看做不可更改的字符列表
print(2 in data)
print(4 not in data)
# in运算符用于确定字符 是否是另外一个字符
# 还可以用作字符串是否是另外一个字符串的子字符串
# 运算符not 可以检测某个元素不在列表里
# 输出如下
# [2, 3, 4, 5, 5.6]
# [2, 3, 4, 2, 3, 4, 2, 3, 4, 2, 3, 4, 2, 3, 4]
# True
# False
# False
在这里插入代码片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
data = [1, 2, 3]
data.append(4)
print(data)
# [1, 2, 3, 4]
用于在列表最后添加元素
print(len(data))
# len函数用于查看列表中的元素
print(data.index(3))
# 查找某个值的索引 (位置)
# output
# [1, 2, 3, 4]
# 4
# 2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# range 函数创建有序数字列表生成
# 一个range（10）生成0-9的整数列表 不包含10 单个参数
data = list(range(10))
print(data)
# 输出
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# range（4,9）生成4-9的整数列表，不包含9 两个参数
data = list(range(4, 10))
print(data)
# 输出
# [4, 5, 6, 7, 8, 9]
# range（3,18,3）生成3-18间隔为3的整数列表 三个参数
data = list(range(3, 18, 3))
print(data)
# 输出
# [3, 6, 9, 12, 15]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
data = [1, 2, 3, 4]
for i in data:
print(i)
for i in range(3):
print(123456)
# 输出
# 1
# 2
# 3
# 4
# 123456
# 123456
# 123456

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
# 代码复习
# def -自定义函数
def my_function():
print("str")
print("hello world")
my_function()
# function函数
# 调用函数之前就必须对它进行定义
否则就会出现以下情况
fun()
def fun():
print("error")
# NameError: name: 'fun' is not defined
# fun（）函数没有定义
# 函数参数
def print_data(data):
print(data + "!")
print_data('data')
print_data("data")
# output
# data!
# data!
# 你可以定义多个参数
用逗号隔开

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 函数返回值
def min(x, y):
if x <= y:
return x
else:
return y
print(min(4, 9))
z = min(5, 6)
print(z)
# output
# 4
# 5
# 函数返回值
# 函数一旦返回一个值 它就立即停止运行 返回语句后任何 代码都不执行
def return_w(x):
y = x
return y
print("这个语句将不会打印")
print(return_w(10))
# output
# 10

1
2
3
4
5
6
7
8
9
10
11
12
13
# 函数对象
# function —函数重新赋值
将函数赋给一个变量， 这样变量就可以调用函数了
# 操作与基本函数输出一样
def open_w(x):
return x
m = 7
op = open_w
# 注意这里是函数名称
不是调用函数
print(op(m))
# 参数记得带上

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 函数也可以作为其他函数的参数
def add(x, y):
return x + y
def do_add(func, x, y):
return func(func(x, y), func(x, y))
a = 45
b = 30
print(do_add((add, a, b)))
# func = add
对应参数输入
do_add 两次将函数add作为参数
# 并且调用它的主体
# TypeError: do_add() missing 2 required positional arguments: 'x' and 'y'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 模块
# random 用来生成随机数 使用基本方法 在文件顶部导入模块名（import module_name)
# 然后使用（module——name.变量名） 访问模块中具有名称的函数和值
import random
import math
from math import pi
# 如果你只需要模块的某个功能 可以另外一种导入 使用（from 模块名 import 变量名） 然后使用变量名
for i in range(5):
value = random.randint(1, 8)
print(value)
num = 3
print(math.sqrt(num))
# 还有math库
sqrt用来求根 根默认是小数 1.当根为整数显示小数后一位0 2.默认显示小数后16位
print(pi)
# pi是数学里面π的值 默认小数点后15位
# modules 错误 导入一个不可以的模块会导致错误

1
2
3
4
5
6
# 尝试导入一个不可用的模块会导致错误
import some_module
print("Result")
# ModuleNotFoundError: No module named 'some_module'
# 模块没有找到错误 ：没有名叫some_module名字的模块

1
2
3
4
5
6
# 可以使用as关键字在不同的名称下导入模块和对象，
# 这主要是在模块和对象具有冗长或混淆的名称时使用
from math import sqrt as sq
print(sq(100))
# 10.0

1
2
3
4
5
6
7
# 异常 常见例子 importerror 导入失败 indexerror 溢出（访问未知空间） nameerror 使用未知变量 sytraceerror 无法正确解析代码
# typeerror 在不适当的类型上调用函数 valueerror 函数调用在正确的类型上，但是具有不适当的值
num1 = 7
num2 = 0
print(num1 / num2)
# ZeroDivisionError: division by zero

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
29
30
31
# 异常处理
可以使用try/except 语句对异常代码进行处理
try:
num1 = 7
num2 = 0
print(num1 / num2)
print("计算完毕")
except ZeroDivisionError:
print("发生了一个错误")
print("一个除以0的操作")
# 发生了一个错误
# 一个除以0的操作
# try语句可以有多个块
用来处理不同的异常
try:
value = 10
print(value + "hello")
print(value / 5)
except ZeroDivisionError:
print("divided by zero")
except (ValueError, TypeError):
print("error occurred")
# error occurred
# 指定的except语句将捕捉所以的错误
try:
sid = "spam"
print(sid / 0)
except:
print("发生了一个错误")
# 发生了一个错误

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
29
30
# finally 语句
为了确保某些代码正常运行 不管发生什么错误 都可以使用最终语句
# 一般把 finally语句放在try/except 语句之后 try/except 中执行也可以
try:
print("hello")
print(1 / 0)
except ZeroDivisionError:
print("0不能做分母")
finally:
print("这条代码是必须的")
# hello
# 0不能做分母
# 这条代码是必须的
try:
print(2)
print(1 / 0)
except ZeroDivisionError:
print(var)
finally:
print("这条代码是必须的")
# ZeroDivisionError: division by zero
# During handling of the above exception, another exception occurred:
# NameError: name 'var' is not # 异常抛出
print(1)
raise ValueError
print(2)
# ValueError
# 处理一个错误的时候，另外一个错误发生，
# 名称错误：没有var没有定义过

1
2
3
4
5
6
# 异常抛出
print(1)
raise ValueError
print(2)
# ValueError

1
2
3
4
5
name = "245"
raise NameError(" invalid name!")
# NameError:
invalid name!

1
2
3
4
5
6
7
8
9
# 在try/except块中，可以使用不带参数的raise语句来引发任何异常
try:
num = 5 / 0
except:
print("一个错误发生")
raise
# 一个错误发生
# ZeroDivisionError: division by zero

1
2
3
4
5
6
7
8
9
10
11
12
# Assertions断点 断点是一种明智的检查，当您完成程序测试时，您可以打开或关闭
# 断点测试表达式，如果结果为false，则引发异常
print(1)
assert 2 + 2 == 4
print(2)
assert 1 + 1 == 3
print(3)
# AssertionError
# assert 1 + 1 == 3
# 1
# 2

1
2
3
4
5
6
7
# 断点可以采用第二个参数 如果断点失败 则传递给断点错误 跟try/except 差不多
# 但是如果不处理 这种类型的异常会终止程序
tem = -10
assert (tem > 0), "小于0"
# assert (tem > 0), "小于0"
# AssertionError: 小于0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 文件用完一定要关闭
# 打开文件 使用open函数打开文件 文本文件最容易
前提是同级目录有名叫 
# file.txt的文件
并且里面有 line1 n line2 n line3 n 
# open("file.txt", 'r')
这里的r代表读取 也可以省略 w代表写入文件
# 用len函数可以求文件大小
# 若要检索文件的每一行 可以使用readlines方法返回一个列表
my_file = open("file.txt", )
print(my_file.readline())
contact = my_file.read()
print(contact)
print(len(contact))
# 长度为0
my_file.close()
# line1
# line2
# line3
# 11

1
2
3
4
5
6
7
8
9
# 您还可以使用for循环来迭代文件中的行
file = open("file.txt", 'r')
for line in file:
print(line)
file.close()
# line1
# line2
# line3

1
2
3
4
5
6
7
8
9
10
# 写入文件 需要使用write方法 ，此方法是将字符串写入文件 w模式如果没有文件
# 它会创建一个 当文件以写模式打开时 文件已有的内容会被删除
file = open("file.txt", 'w')
file.write("写入字符串在文件里")
file.close()
file = open("file.txt", 'r')
print(file.read())
file.close()
# 写入字符串在文件里

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
file = open("file.txt", 'r')
print("初始化读写内容")
print(file.read())
print("完成")
file.close()
file = open("file.txt", 'w')
file.write("新的内容")
file.close()
file = open("file.txt", 'r')
print("写入新的内容")
print(file.read())
print("结束")
file.close()
# 初始化读写内容
# 写入字符串在文件里
# 完成
# 写入新的内容
# 新的内容
# 结束

1
2
3
4
5
6
7
8
9
# 用write 方法返回写入文件的字节数
words = "hello world"
file = open("file.txt", 'w')
count_words = file.write(words)
print(count_words)
file.close()
#
字节数11

1
2
3
4
5
6
7
8
9
10
11
12
13
# 使用文件
# 关闭文件 用try/finally 更好确保文件关闭 即使发生错误
try:
file = open("file.txt")
print(file.read())
finally:
file.close()
# hello world
# 处理文件 还有第二种方法 with 语句
with open("file.txt") as f:
print(f.read())
# hello world

1
2
3
4
5
6
7
8
9
# none 空 是一个类型
也是一个对象不等于 空的字符串 不等于空的列表 不等于0 不等于False
# lambda 函数不像 命名函数那么强大 只能做单个表达式 等同于一行代码
def poll(x):
# 命名函数
return x ** 2 + 5 * x + 4
print(poll(-4))
# 0

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

print((lambda x: x ** 2 + 5 * x + 4)(-4))
# x=-4
# 0
# 字典 字典用于将任意键映射到值的数据结构
# 字典可以用于与列表相同的方式索引 ，使用包含键的方括号
ages = {"Dave": 24, "Mary": 42, "John": 58}
print(ages["Dave"])
print(ages["Mary"])
# 24
# 42
# 字典中的每个元素都由键: 值对表示
# 试图索引不是词典的一部分的键 返回值错误
# print(ages["MM"])
# KeyError: 'MM' 键错误
# 对象不可变（还有列表）
# tuple元组
# 元组和列表非常相似，除了他们是不可变的（它们不能被改变）
# 用括号创建
不是方括号 用逗号分隔
eggs = ("span", "eggs", "message")
print(eggs[0])
# span
# 试图重新赋值元组的值会导致错误，即不支持赋值
# eggs[0] = "mm"
# TypeError: 'tuple' object does not support item assignment
#
列表切片 列表名字[开始位置:结束位置]
mm = [0, 1, 2, 3, 4, 5, 6, 6, 5, 5, 56, 6, 56, 6]
print(mm[2:10])
# [2, 3, 4, 5, 6, 6, 5, 5]
# 如果忽略第一个数 默认从开头开始
忽略第二个数字
会默认输出到结尾
print(mm[:10])
print(mm[7:])
# [0, 1, 2, 3, 4, 5, 6, 6, 5, 5]
# [6, 5, 5, 56, 6, 56, 6]
# 列表切片还有第三个数字 表示步进
不包含最后一个
# 数字为负 表示从尾部开始计数
# 列表推导式
app = [i ** 3 for i in range(5)]
# 循环5次
print(app)
# [0, 1, 8, 27, 64]
# 嵌套if语句 来强制列表中的值的条件。
en = [i ** 2 for i in range(5) if i ** 2 % 2 == 0]
print(en)
# [0, 4, 16]
# 试图在一个非常广泛的范围内创建列表会导致内存错误
# ene = [2 * 3 for i in range(10 ** 100)]
# MemoryError
# 字符串格式化
# 将非字符串转化为字符
nums = [4, 5, 9]
msg = "numbers:{0} {1} {2}".format(nums[0], nums[1], nums[2])
print(msg)
# numbers:4 5 9
# 把每个参数放在对应未知的字符串中这是使用{}确定的
a = "{x}, {y}".format(x=5, y=7)
print(a)
# 5, 7
# 有用的函数
# 字符串函数
print(",".join(["spam", "edd"]))
# spam,edd
列表转字符串 带有某个分隔符
print("hello me".replace("me", "world"))
# hello world 替换对应的字符
print("this is.".startswith("this"))
# True 开头是否有 某字符串
print("this is.".endswith("is."))
# True
结尾是否有某字符串
print("this is.".upper())
# THIS IS.
全部大写
print("this is.".lower())
# this is.全部小写
print("this, is".split(","))
# ['this', ' is'] 字符串转列表 带有某个分隔符
# 数值函数
print(min(1, 3, 2, 4, 65, 5, 6, 5, 5, 6))
# 1
print(max(1, 2, 3, 585, 6, 4, 56, 4, 6))
# 585
print(abs(-997))
# 绝对值
# 997
print(sum([1, 2, 6, 56, 43, 34]))
# 142
# 列表函数
numd = [22, 55, 44, 77, 88]
if all([i > 5 for i in numd]):
print("所有比5大的")
# 所有比5大的
if any([i % 2 == 0 for i in numd]):
print("输出偶数")
# 输出偶数
for m in enumerate(numd):
print(m)
# (0, 22)
# (1, 55)
# (2, 44)
# (3, 77)
# (4, 88)
# 文本分析器
def count_char(text, char):
count = 0
for c in text:
if c == char:
count += 1
return count
filename = input("请输入文件名：")
with open(filename) as f:
text = f.read()
print(count_char(text, "r"))
f.close()
# 结果是 1
# 查询r在文件中出现的次数
def count_char(text, char):
count = 0
for c in text:
if c == char:
count += 1
return count
filename = input("请输入文件名：")
with open(filename) as f:
text = f.read()
print(count_char(text, "r"))
for char in "abcdefghijklmnopqrstuvwxyz":
perc = 100 * count_char(text, char) / len(text)
print("{0} - {1}%".format(char, round(perc, 2)))
f.close()
# 查找字母表中每个字符所占的百分比
# 1
# a - 0.0%
# b - 0.0%
# c - 0.0%
# d - 9.09%
# e - 9.09%
# f - 0.0%
# g - 0.0%
# h - 9.09%
# i - 0.0%
# j - 0.0%
# k - 0.0%
# l - 27.27%
# m - 0.0%
# n - 0.0%
# o - 18.18%
# p - 0.0%
# q - 0.0%
# r - 9.09%
# s - 0.0%
# t - 0.0%
# u - 0.0%
# v - 0.0%
# w - 9.09%
# x - 0.0%
# y - 0.0%
# z - 0.0%

1
2
3
4
5
6
7
def pure_function(x, y):
temp = x + 2*y
return temp / (2*x + y)
some_list = []
def impure(arg):
some_list.append(arg)

1
2
3
4
5
6
7
8
9
#命名函数
def polynomial(x):
return x**2 + 5*x + 4
print(polynomial(-4))
#lambda
print((lambda x: x**2 + 5*x + 4) (-4))
</b></b>
>>>结果： 0

1
2
3
4
5
6
7
double = lambda x: x * 2
print(double(7))
结果：
>>>
14
>>>

1
2
3
4
5
6
7
8
9
10
def add_five(x):
return x + 5
nums = [11, 22, 33, 44, 55]
result = list(map(add_five, nums))
print(result)
结果：
>>>
[16, 27, 38, 49, 60]
>>>

1
2
3
4
nums = [11, 22, 33, 44, 55]
result = list(map(lambda x: x+5, nums))
print(result)

1
2
3
4
5
6
7
8
def countdown():
i=5
while i > 0:
yield i
i -= 1
for i in countdown():
print(i)

1
2
3
4
5
6
def numbers(x):
for i in range(x):
if i % 2 == 0:
yield i
print(list(numbers(11)))

1
2
3
4
5
6
def infinite_sevens():
while True:
yield 7
for i in infinite_sevens():
print(i)

1
2
3
4
nums = [11, 22, 33, 44, 55]
res = list(filter(lambda x: x%2==0, nums))
print(res)

1
2
3
4
5
6
def numbers(x):
for i in range(x):
if i % 2 == 0:
yield i
print(list(numbers(11)))

1
2
3
4
5
6
7
8
9
10
11
def decor(func):
def wrap():
print("============")
func()
print("============")
return wrap
def print_text():
print("Hello world!")
decorated = decor(print_text)
decorated()

1
2
3
4
5
结果:
============
Hello world!
============

1
2
3
4
5
6
7
8
9
10
def decor(func):
def wrap():
print("============")
func()
print("============")
return wrap
def print_text():
print("Hello world!")
print_text = decor(print_text)

1
2
3
4
@decor
def print_text():
print("Hello world!")

1
2
3
4
5
6
7
8
9
10
def is_even(x):
if x == 0:
return True
else:
return is_odd(x-1)
def is_odd(x):
return not is_even(x)
print(is_odd(17))
print(is_even(23))

1
2
3
4
5
6
nums = {1, 2, 1, 3, 1, 4, 5, 6}
print(nums)
nums.add(-7)
nums.remove(3)
print(nums)

1
2
3
4
5
6
7
8
first = {1, 2, 3, 4, 5, 6}
second = {4, 5, 6, 7, 8, 9}
print(first | second)
print(first & second)
print(first - second)
print(second - first)
print(first ^ second)

1
2
3
4
5
from itertools import accumulate, takewhile
nums = list(accumulate(range(8)))
print(nums)
print(list(takewhile(lambda x: x<= 6, nums)))

1
2
3
4
5
6
7
8
class Cat:
def __init__(self, color, legs):
self.color = color
self.legs = legs
felix = Cat("蛋黄", 4)
rover = Cat("绿色", 4)
stumpy = Cat("棕色", 3)

1
2
3
4
5
6
7
class Cat:
def __init__(self, color, legs):
self.color = color
self.legs = legs
felix = Cat("ginger", 4)
print(felix.color)

1
2
3
4
5
6
7
8
class Cat:
def __init__(self, color, legs):
self.color = color
self.legs = legs
felix = Cat("蛋黄", 4)
rover = Cat("绿色", 4)
stumpy = Cat("棕色", 3)

1
2
3
4
5
6
7
class Cat:
def __init__(self, color, legs):
self.color = color
self.legs = legs
felix = Cat("ginger", 4)
print(felix.color)

1
2
3
4
5
6
Student
def (self, name):
self
= name
test = Student("Bob")

1
2
3
4
5
6
7
8
9
10
class Dog:
def __init__(self, name, color):
self.name = name
self.color = color
def bark(self):
print("Woof!")
fido = Dog("Fido", "brown")
print(fido.name)
fido.bark()

1
2
3
4
5
6
7
8
9
class Dog:
legs = 4
def __init__(self, name, color):
self.name = name
self.color = color
fido = Dog("Fido", "brown")
print(fido.legs)
print(Dog.legs)

1
2
3
4
5
6
7
class Rectangle:
def __init__(self, width, height):
self.width = width
self.height = height
rect = Rectangle(7, 8)
print(rect.color)

1
2
3
4
5
6
7
8
9
10
11
12
class Rectangle:
def __init__(self, width, height):
self.width = width
self.height = height
def calculate_area(self):
return self.width * self.height
@classmethod
def new_square(cls, side_length):
return cls(side_length, side_length)
square = Rectangle.new_square(5)
print(square.calculate_area())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<b><b>
class Animal:
def __init__(self, name, color):
self.name = name
self.color = color
class Cat(Animal):
def purr(self):
print("咕噜咕噜...")
class Dog(Animal):
def bark(self):
print("旺旺旺!")
fido = Dog("Fido", "棕色")
print(fido.color)
fido.bark()
</b></b>
结果：
<b><b><b><b>
>>>
棕色
旺旺旺!
>>>
</b></b></b></b>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Wolf:
def __init__(self, name, color):
self.name = name
self.color = color
def bark(self):
print("喔...")
class Dog(Wolf):
def bark(self):
print("旺旺旺！")
husky = Dog("Max", "grey")
husky.bark()
结果：
>>>
旺旺旺！
>>>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class A:
def method(self):
print("A method")
class B(A):
def another_method(self):
print("B method")
class C(B):
def third_method(self):
print("C method")
c = C()
c.method()
c.another_method()
c.third_method()
结果：
>>>
A method
B method
C method
>>>

1
2
3
4
5
6
7
8
9
class A:
def spam(self):
print(1)
class B(A):
def spam(self):
print(2)
super().spam()
B().spam()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Vector2D:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Vector2D(self.x + other.x, self.y + other.y)
first = Vector2D(5, 7)
second = Vector2D(3, 9)
result = first + second
print(result.x)
print(result.y)
结果：
>>>
8
16
>>>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class SpecialString:
def __init__(self, cont):
self.cont = cont
def __truediv__(self, other):
line = "=" * len(other.cont)
return "
".join([self.cont, line, other.cont])
spam = SpecialString("spam")
hello = SpecialString("Hello world!")
print(spam / hello)
结果：
>>>
spam
============
Hello world!
>>>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class SpecialString:
def __init__(self, cont):
self.cont = cont
def __gt__(self, other):
for index in range(len(other.cont)+1):
result = other.cont[:index] + ">" + self.cont
result += ">" + other.cont[index:]
print(result)
spam = SpecialString("spam")
eggs = SpecialString("eggs")
spam > eggs
结果：
>>>
>spam>eggs
e>spam>ggs
eg>spam>gs
egg>spam>s
eggs>spam>
>>>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import random
class VagueList:
def __init__(self, cont):
self.cont = cont
def __getitem__(self, index):
return self.cont[index + random.randint(-1, 1)]
def __len__(self):
return random.randint(0, len(self.cont)*2)
vague_list = VagueList(["A", "B", "C", "D", "E"])
print(len(vague_list))
print(len(vague_list))
print(vague_list[2])
print(vague_list[2])
结果：
>>>
6
7
D
C
>>>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
a = 42
# 创建对象 <42>
b = a
# 增加对象指向 <42>
c = [a]
#f增加对象指向
<42>
del a
# Decrease ref. count
of <42>
b = 100
# Decrease ref. count
of <42>
c[0] = -1
# Decrease ref. count
of <42>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Queue:
def __init__(self, contents):
self._hiddenlist = list(contents)
def push(self, value):
self._hiddenlist.insert(0, value)
def pop(self):
return self._hiddenlist.pop(-1)
def __repr__(self):
return "Queue({})".format(self._hiddenlist)
queue = Queue([1, 2, 3])
print(queue)
queue.push(0)
print(queue)
queue.pop()
print(queue)
print(queue._hiddenlist)

1
2
3
4
5
6
7
8
9
class Spam:
__egg = 7
def print_egg(self):
print(self.__egg)
s = Spam()
s.print_egg()
print(s._Spam__egg)
print(s.__egg)

1
2
3
4
5
6
7
8
9
10
11
12
13
class Pizza:
def __init__(self, toppings):
self.toppings = toppings
@staticmethod
def validate_topping(topping):
if topping == "pineapple":
raise ValueError("No pineapples!")
else:
return True
ingredients = ["cheese", "onions", "spam"]
if all(Pizza.validate_topping(i) for i in ingredients):
pizza = Pizza(ingredients)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Pizza:
def __init__(self, toppings):
self.toppings = toppings
@property
def pineapple_allowed(self):
return False
pizza = Pizza(["cheese", "tomato"])
print(pizza.pineapple_allowed)
pizza.pineapple_allowed = True
结果：
>>>
False
AttributeError: can't set attribute
>>>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Pizza:
def __init__(self, toppings):
self.toppings = toppings
self._pineapple_allowed = False
@property
def pineapple_allowed(self):
return self._pineapple_allowed
@pineapple_allowed.setter
def pineapple_allowed(self, value):
if value:
password = input("Enter the password: ")
if password == "Sw0rdf1sh!":
self._pineapple_allowed = value
else:
raise ValueError("Alert! Intruder!")
pizza = Pizza(["cheese", "tomato"])
print(pizza.pineapple_allowed)
pizza.pineapple_allowed = True
print(pizza.pineapple_allowed)

1
2
3
4
5
6
7
import re
pattern = r"spam"
if re.match(pattern, "spamspamspam"):
print("匹配")
else:
print("不匹配")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import re
pattern = r"spam"
if re.match(pattern, "eggspamsausagespam"):
print("Match")
else:
print("No match")
if re.search(pattern, "eggspamsausagespam"):
print("Match")
else:
print("No match")
print(re.findall(pattern, "eggspamsausagespam"))
结果：
>>>
No match
Match
['spam', 'spam']
>>>

1
2
3
4
5
6
7
8
9
import re
pattern = r"pam"
match = re.search(pattern, "eggspamsausage")
if match:
print(match.group())
print(match.start())
print(match.end())
print(match.span())

1
2
3
4
5
6
import re
str = "My name is David. Hi David."
pattern = r"David"
newstr = re.sub(pattern, "Amy", str)
print(newstr)

1
2
3
4
5
6
7
8
9
import re
pattern = r"gr.y"
if re.match(pattern, "grey"):
print("Match 1")
if re.match(pattern, "gray"):
print("Match 2")
if re.match(pattern, "blue"):
print("Match 3")

1
2
3
4
5
6
7
8
9
import re
pattern = r"^gr.y$"
if re.match(pattern, "grey"):
print("Match 1")
if re.match(pattern, "gray"):
print("Match 2")
if re.match(pattern, "stingray"):
print("Match 3")

1
2
3
4
5
6
7
8
9
mport re
pattern = r"[aeiou]"
if re.search(pattern, "grey"):
print("Match 1")
if re.search(pattern, "qwertyuiop"):
print("Match 2")
if re.search(pattern, "rhythm myths"):
print("Match 3")

1
2
3
4
5
6
7
8
9
mport re
pattern = r"[aeiou]"
if re.search(pattern, "grey"):
print("Match 1")
if re.search(pattern, "qwertyuiop"):
print("Match 2")
if re.search(pattern, "rhythm myths"):
print("Match 3")

1
2
3
4
5
6
7
8
9
mport re
pattern = r"[A-Z][A-Z][0-9]"
if re.search(pattern, "LS8"):
print("Match 1")
if re.search(pattern, "E3"):
print("Match 2")
if re.search(pattern, "1ab"):
print("Match 3")

1
2
3
4
5
6
7
8
9
import re
pattern = r"[^A-Z]"
if re.search(pattern, "this is all quiet"):
print("Match 1")
if re.search(pattern, "AbCdEfG123"):
print("Match 2")
if re.search(pattern, "THISISALLSHOUTING"):
print("Match 3")

1
2
3
4
5
6
7
8
9
import re
pattern = r"egg(spam)*"
if re.match(pattern, "egg"):
print("匹配 1")
if re.match(pattern, "eggspamspamegg"):
print(""匹配 2")
if re.match(pattern, "spam"):
print(""匹配 3")

1
2
3
4
5
6
7
8
9
import re
pattern = r"g+"
if re.match(pattern, "g"):
print("Match 1")
if re.match(pattern, "gggggggggggggg"):
print("Match 2")
if re.match(pattern, "abc"):
print("Match 3")

1
2
3
4
5
6
7
8
9
10
11
import re
pattern = r"ice(-)?cream"
if re.match(pattern, "ice-cream"):
print("Match 1")
if re.match(pattern, "icecream"):
print("Match 2")
if re.match(pattern, "sausages"):
print("Match 3")
if re.match(pattern, "ice--ice"):
print("Match 4")

1
2
3
4
5
6
7
8
9
import re
pattern = r"9{1,3}$"
if re.match(pattern, "9"):
print("Match 1")
if re.match(pattern, "999"):
print("Match 2")
if re.match(pattern, "9999"):
print("Match 3")

1
2
3
4
5
6
7
8
9
10
import re
pattern = r"a(bc)(de)(f(g)h)i"
match = re.match(pattern, "abcdefghijklmnop")
if match:
print(match.group())
print(match.group(0))
print(match.group(1))
print(match.group(2))
print(match.groups())

1
2
3
4
5
6
7
8
9
import re
pattern = r"egg(spam)*"
if re.match(pattern, "egg"):
print("Match 1")
if re.match(pattern, "eggspamspamspamegg"):
print("Match 2")
if re.match(pattern, "spam"):
print("Match 3")

1
2
3
4
5
6
7
8
9
10
11
12
import re
pattern = r"gr(a|e)y"
match = re.match(pattern, "gray")
if match:
print ("Match 1")
match = re.match(pattern, "grey")
if match:
print ("Match 2")
match = re.match(pattern, "griy")
if match:
print ("Match 3")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import re
pattern = r"b(cat)b"
match = re.search(pattern, "The cat sat!")
if match:
print ("Match 1")
match = re.search(pattern, "We s>cat<tered?") if="" match:="" print="" ("match="" 2")="" match="re.search(pattern," "we="" scattered.")="" 3")="" <="" pre="">
<p class="resu"><b>结果：<b></b></b></p><b><b>
<pre class="brush:python">
>>>
Match 1
Match 2
>>>
</pre>
<div class="tip">
"b(cat)b"基本匹配单词“CAT”包围的单词边界。
</div>
</b></b></tered?")>

1
2
3
4
5
6
7
8
9
10
11
12
import re
pattern = r"(.+) 1"
match = re.match(pattern, "word word")
if match:
print ("Match 1")
match = re.match(pattern, "?! ?!")
if match:
print ("Match 2")
match = re.match(pattern, "abc cde")
if match:
print ("Match 3")

1
2
3
4
5
6
7
8
9
10
11
12
import re
pattern = r"(D+d)"
match = re.match(pattern, "Hi 999!")
if match:
print("Match 1")
match = re.match(pattern, "1, 23, 456!")
if match:
print("Match 2")
match = re.match(pattern, " ! $?")
if match:
print("Match 3")

1
2
3
4
5
6
7
import re
pattern = r"([w.-]+)@([w.-]+)(.[w.]+)"
str = "Please contact info@sololearn.com for assistance"
match = re.search(pattern, str)
if match:
print(match.group())