Python 编程从入门到实践

一、Jetbrains系列软件常用快捷键

代码的格式化：Ctrl+Alt+L
调出快速搜索框：两次Shift
打开的文件中查找：Ctrl+F
全局查找快捷键默认：Ctrl+Shift+F （如果不可以就是与搜狗输入法的冲突了）
Getter和Setter封装：Alt+Insert
自动补全代码：Alt+/
注释代码：Ctrl+/
撤销：Ctrl+Z
撤销返回：Ctrl+Shift+Z
复制本行代码到下一行：Ctrl+D
删除光标所在行的代码：Ctrl+Y
自动注释代码：Ctrl+Shift+/
万能的快捷键：Alt+Enter
测试接口的类：在要测试的上Ctrl + shift + t
快速展开/折叠全部方法：Ctrl + Shift + " +/- "
向上插入一行空格：CTRL+Enter
向下插入一行空格：Shift+Enter
上端或下端插入一空行：shift+Alt+方向键
快速给代码加上组合语句try/catch等：CTRL+ALT+T
多行相同的代码一起修改或者删除：Ctrl+Shift+Alt 或者 按住鼠标的滚轮向下拉 也可！
运行编写的py文件：Ctrl+Shift+F10

二、《Python 编程从入门到实践》P1~P200 学习总结

1.基本数据类型的运算

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
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
 复制代码 隐藏代码print("Python针对于字符串的大小写和去除空白")
message = "\tpython xue xi\t"
# 每个单词的首字母大写的写法
print(message.title())
# 单词全部大写的写法
print(message.upper())  
#  单词全部小写的写法
print(message.lower())  
# 去除字符串前面的空白
print(message.lstrip())
# 去除字符串后面的空白
print(message.rstrip())
# 去除字符串两边的空白
print(message.strip())

print("\nPython的加减乘除混合运算和幂运算")
print(3 + 2)
print(3 - 2)
print(3 * 2)
print(3 / 2)
print(3 ** 2 + 3)
print(0.1 + 2)
print(0.1 + 0.2)
print(0.1 * 2)
print((1 + 2 - 1) * 4 / 4)

print("\n使用函数str()避免类型的错误")
age = 20
print("我今年的年龄是" + str(age) + "岁\n")

print("Python的列表和访问元素和元素的大小写以及去除空格")
shenghuo = ["chifan", "xuexi", "shuijiao", " shangban"]
print(shenghuo)
print(shenghuo[0].title())  #首字母大写
print(shenghuo[1].upper())        #全部字母大写
print(shenghuo[2].lower())        #全部字母小写
print(shenghuo[3].lstrip())        #去除字符串前面的空白
# 访问列表的元素于去除空格和拼接字符的混合使用
print(shenghuo[-1])
print(shenghuo[-2])
print("一天中要先" + shenghuo[0] + "然后再" + shenghuo[-1].lstrip() + "继续再" + shenghuo[1] + "最后再" + shenghuo[-2])

# 修改 添加 删除 元素
che = ["motuo", "qiche", "zixingche", 'huoche']
print(che)
# 修改
che[0] = "kache"
print(che)
# 添加
che.append("danche")
print(che)

#定义一个空列表
aihao = []
aihao.append("chifan")
aihao.append("shuijiao")
aihao.append("dadoudou")
print(aihao)

# 在列表中插入元素
aihao.insert(1, "xuexi")
print(aihao)

# 删除
del aihao[2]
print(aihao)
del aihao[-1]
print(aihao)

# pop删除列表中最后元素并使用删除的最后元素
shanzuihou = aihao.pop()
print(shanzuihou)
print("现在我唯一的爱好是" + shanzuihou.title())
shanchu = aihao.pop(0)
print(shanchu)
print("我每天都要" + shanchu.title())

# 根据值移除元素
che = ["motuo", "qiche", "zixingche", 'huoche']
che.remove("huoche")
print(che)
che.remove("motuo")
print(che)

# 组织列表 sort() 永久性排序 abcde正向或逆向顺序排序
che = ["motuo", "qiche", "zixingche", 'huoche']
# 正向的排序
che.sort()
print(che)
# 反向的排序
che.sort(reverse=True)
print(che)

# 组织列表 sorted() 临时性排序  abcde正向或逆向顺序排序
# 临时正向排序
print(sorted(che))
# 临时反向排序
print(sorted(che, reverse=True))

# 倒着打印列表  永久性的修改顺序 也可以随时改回来
che = ["motuo", "qiche", "zixingche", 'huoche']
# 倒着打印
che.reverse()
print(che)
# 再次倒着改回
che.reverse()
print(che)

# 确认列表的长度 结果为4
che = ["motuo", "qiche", "zixingche", 'huoche']
print(len(che))

# for循环遍历整个列表   for 变量名 in 遍历的列表变量名:
che = ["motuo", "qiche", "zixingche", 'huoche']
for che1 in che:
    print(che1)

# 在for循环中执行更多的操作 Python 对于缩进是极为的严格
for che2 in che:
    print(che2.title() + '都是交通工具！')
print("出门的时候都可以使用！")

# 直接的在for循环中创建打印列表
for wenzi in ["你好", "我也好"]:
    print(wenzi)

# 创建数字列表
for shuzi in range(1, 5):
    print(shuzi)

# 将1-4 输出为一个数列表
number = list(range(1, 5))
print(number)
# 将numer中的列表通过for循环遍历出来
for num in number:
    print(num)

# 打印10以内的偶数 从第一个数 2开始不断的加2
oushu = list(range(2, 10, 2))
print(oushu)

# 1-10每个整数的平方组成一个列表
liebiaos = []
for value in range(1, 11):
    liebiaos.append(value ** 2)
print(liebiaos)
print(liebiaos[-1])

# 对数字列表进行简单的统计 最大值，最小值，求和
number = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(max(number))
print(min(number))
print(sum(number))

# 对数字列表解析 列表中每个数的平方赋值给message
message = [value ** 3 for value in range(1, 11)]
print(message)

# 列表的一部分 切片
che = ["motuo", "qiche", "zixingche", 'huoche']
print(che[0:2])
print(che[1:-1])
print(che[:4])  # 没有指定一个开头的索引，默认从0开始
print(che[0:])  # 没有指定一个结尾的索引，默认到最后结束

# for循环遍历切片 并让单词的首字母大写
che = ["motuo", "qiche", "zixingche", 'huoche']
for che3 in che[:2]:
    print(che3.title())

# 复制列表  以及验证列表是两个列表
che = ["motuo", "qiche", "zixingche", 'huoche']
gongju = che[:]
print(che)
print(gongju)
# 验证复制的列表是两个列表
che.append("kache")
print(che)
gongju.append("daba")
print(gongju)

# 元组：Python将不能修改的值称为不可变的，而不可变的列表被称为元组！ 不能修改的是元素，而变量是可以修改的
# 定义元组  遍历元组中的所有的值
yuanzu = (100, 50)
print(yuanzu[0])
print(yuanzu[1])

# for遍历元组的所有值
yuanzu = (100, 20, 30)
for bianli in yuanzu:
    print(bianli)

# for修改元组变量
yuanzu = (100, 50)
for bianli in yuanzu:
    print(bianli)
yuanzu = (200, 300)
for bianli in yuanzu:
    print(bianli)

# if语句的使用 不是根据条件顺序输出，而是根据列表的排列顺序和条件输出
che = ["motuo", "qiche", "zixingche", 'huoche']
for che1 in che:
    if che1 == 'qiche':
        print(che1.upper())  # 全部大写  QICHE
    else:
        print(che1.title())  # 首字母大写   Motuo Zixingche Huoche

# 检查特定值是否包含在列表中 或者 是否不包含在列表中
che = ["motuo", "qiche", "zixingche", 'huoche']
baohan = 'huoche1'
if baohan in che:
    print(baohan + '包含在列表中')
else:
    print((baohan + "不包含在列表中"))
if baohan not in che:
    print(baohan.title() + '不包含在列表中')

# 简单的条件判断语句的使用 if if-else if_elif-else
a = 18
if a > 17:
    print('a的值大于17')
if a > 19:
    print('a的值大于19')
else:
    print('a的值小于19')
if a > 19:
    print('a的值大于19')
elif a == 18:  # Java中的 else if 在Python 中就是elif
    print('a的值是18')
else:
    print('a的值小于19')

2.Python之禅

1
2
 复制代码 隐藏代码
import this

img

3.Python关键字

1
2
3
4
5
6
 复制代码 隐藏代码# 输出Python 中的关键字
# ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del',
# 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda',
# 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
import keyword
print(keyword.kwlist)

4.Python ()[]{}区别

() 表示元组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 复制代码 隐藏代码# 元组：Python将不能修改的值称为不可变的，而不可变的列表被称为元组！ 不能修改的是元素，而变量是可以修改的
# 定义元组  遍历元组中的所有的值
yuanzu = (100, 50)
print(yuanzu[0])
print(yuanzu[1])
# for遍历元组的所有值
yuanzu=(100,20,30)
for bianli in yuanzu:
    print(bianli)
# for修改元组变量
yuanzu = (100, 50)
for bianli in yuanzu:
    print(bianli)
yuanzu=(200,300)
for bianli in yuanzu:
    print(bianli)

[]表示列表

1
2
3
4
5
6
7
8
9
10
11
12
 复制代码 隐藏代码# 组织列表 sort() 永久性abcde正向或逆向排序
che = ["motuo", "qiche", "zixingche", 'huoche']
# 正向的排序
che.sort()
print(che)
# 反向的排序
che.sort(reverse=True)
print(che)
# 组织列表 sorted() 临时性abcde 正向或逆向排序
# 临时正向排序
print(sorted(che))
print(sorted(che, reverse=True))

{}大括号表示字典

1
2
3
4
 复制代码 隐藏代码# Python字典{} 相当于Java中的键值对
che = {"motuo":'motuoche', 'huoche':5}
print(che['motuo'])
print(che['huoche'])

5.字典和列表(嵌套)使用

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
 复制代码 隐藏代码# Python字典{} 键-值对
che = {"motuo": 'motuoche', 'huoche': 5}
print(che['motuo'])
print(che['huoche'])

# 字典添加键-值对
che = {"motuo": 'motuoche', 'huoche': 5}
che['kache'] = 1
che['qiche'] = 3
print(che)

# 创建一个空字典 添加、修改、删除键-值对
che1 = {}
che1['kache'] = 'green'
che1['motuo'] = '1'
che1['huoche'] = '2'
che1['qiche'] = '3'
che1['daba'] = 'red'
print(che1)

# 修改字典中的值
che2 = {'kache': 'green'}
print(che2)
che2['kache'] = 'yellow'
print(che2)

# 删除键-值对
che1 = {'kache': 'green', 'motuo': '5', 'huoche': '2', 'qiche': '3', 'daba': 'red'}
print(che1)
del che1['huoche']
print(che1)
che1['huoche'] = '4'  # 重新添加回删除的键-值对
print(che1)
print('kache交通工具的颜色：' + che1['kache'].title() + '\t' + 'daba交通工具的颜色是' + che1['daba'].upper())
# for 循环遍历 打印出键值对中所有的键
for key in che1.keys():
    print(key.title())
# for 循环遍历 打印出键值对中的所有的值
for value in che1.values():
    print(value)
# for 循环遍历打印出 键值对中所有的键 并 按照顺序排序
for key in sorted(che1.keys()):
    print(key.upper().lower().title())  # 将 打印出来的键的值先全部大写 之后小写 然后在把首字母大写输出
# for 循环遍历出键值对中所有的值 并 按照顺序排列
for value in sorted(che1.values()):
    print(str(value.upper().lower().title()))

# 在列表中存储字典 组合 打印出每一个键值对的字典 或者 列表中所有的字典
che1 = {'kache': '5', 'motuo': '10'}
che2 = {'huoche': '20', 'qiche': '15', }
che3 = {'gongjiao': '30', 'daba': '25'}
che = [che1, che2, che3]
for gongju in che:
    print(gongju)
# 打印显示列表中的 前两个 字典键值对
for gongju2 in che[:2]:
    print(gongju2)
# 复制前两个键值对的列表 并在里面添加新的键值对 并查看原来的和复制之后的字典组成的列表 / 在列表中存储字典
che4 = che[:]
a = {'mache': '35', 'luche': '40'}
che4.append(a)
print(che)
print(che4)
print(str(len(che4)))  # 显示列表中总共有多少个字典

# 在字典中存储列表 通过遍历打印出来所有列表中的值
che1 = {'kache': 'dakache',
        'motuo': ['xiaomotuo', 'damotuo'],
        }
for motuo1 in che1['motuo']:
    print(motuo1)
print("拉货用" + che1['kache'] + '\t' + "摩托车是" + motuo1)
# 在字典中存储字典 并且访问每一级字典中的键 和 值的数据
che5 = {'che6': {'kache': '5', 'huoche': '6'}}
for key, value in che5.items():
    print(key)
    print(value)
    b=value
    print(b.keys())
    print(b.values())

6.用户输入和while循环

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
 复制代码 隐藏代码# 用户输入和while循环 函数input()
message = input('用户请输入：')
print("输出了用户输入的：\t" + message)

# 使用Input输出一句名言 并拼接输出一句完整的话
qian = "说做过的，"
hou = '做说过的！'
name = input('请输入这是谁说的话：')
print(qian + hou + '\n' + '\t\t\t' + '————' + name)

# 求模运算 根据用户输入的数字 判断用户输入的是奇数还是偶数！
number = input("请任意输入一个不为0的整数：")
number = int(number)
if number % 2 == 0:
    print('用户输入的这个数为' + str(number) + '是一个偶数！')
else:
    print('用户输入的这个数为' + str(number) + '是一个是奇数！')

# 让用户自己选择何时退出 只要用户输入的数据不等于jieshu 就会一直让用户输入数据 当用户输入jieshu直接退出循环
message=''
while message!='jieshu':
    message=input('请输入：') #输入jieshu 直接终止程序
    if message!='jieshu':  #使用if语句可以减少最后的jieshu的打印 message不等于jieshu的时候才打印 否则反之！
        print(message)
 复制代码 隐藏代码# while 让用户选择何时推出循环 while 循环默认的是True 默认执行的是循环并输出信息 只有当用户输入的是tuichu的时候Active 才是False 就会结束！
xinxi='请输入信息:'
active=True
while active:
    message=input(xinxi)
    if message=='tuichu':
        active=False
    else:
        print(message)

# 如果用户输入的是 tuichu则使用break跳出循环
xinxi='请输入信息:'
active=True
while active:
    message=input(xinxi)
    print(message)
    if message=='退出':
        break
    else:
        print("I love You"+message)

# 在循环中使用 continue 输出1~10数字的奇数
shuzi = 0
while shuzi < 10:
    shuzi += 1
    if shuzi % 2 == 0:
        continue
    print(shuzi)

# 使用while 循环来处理 列表 字典
unconfirmed_users=['alice','brian','candace']
confirmed_users=[]
while unconfirmed_users:
    current_user=unconfirmed_users.pop()
    print(current_user.title())
    confirmed_users.append(current_user)

# 删除包含特定值的列表元素
che = ["motuo", "qiche", "zixingche", 'huoche'];
print(che)
# 移除qiche
while 'qiche' in che:
    che.remove('qiche')
print(che)

# 使用用户输入来填充字典 让用户自己决定是否继续调查 默认为True
responses={}
active=True
while active:
    name=input('\n你叫什么名字？请输入：')
    respons=input('从哪里来？请输入：')
    responses[name]=respons
    repeat=input('还有人要参与调查吗？(yes/no)')
    if repeat=='no':
        active=False
for name,response in responses.items():
    print(name+'\t'+response)

7.函数

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
 复制代码 隐藏代码# Python 的函数 相当于是java中的方法
def greet_user():
    '''输出一句话'''
    print("输出一句话")
greet_user()

# 向函数传递信息 实参：rj  形参：username
def greet_user(username):
    print('这个人叫'+username)
greet_user('rj')

#实参和形参 传递实参 位置实参 多次调用函数
def describe_pet(animal_type,pet_name):
    '''显示宠物的信息'''
    print('宠物的类型是：'+animal_type+'.')
    print('宠物的名字是:'+pet_name.title()+'.\n')
describe_pet('小型','h士奇')
describe_pet('大型','z獒')

# 关键字实参 可以无视顺序：在写实参的时候，不用遵循形参的顺序  多次调用函数验证
def describe_pet(animal_type,pet_name):
    '''显示宠物的信息'''
    print('宠物的类型是：'+animal_type+'.')
    print('宠物的名字是:'+pet_name.title()+'.\n')
describe_pet(animal_type='中型',pet_name='m羊犬')
describe_pet(pet_name='m羊犬',animal_type='中型')

#函数 可以设置形参的默认值
def describe_pet(animal_type,pet_name='s魔灰'):
    '''显示宠物的信息'''
    print('宠物的类型是：'+animal_type+'.')
    print('宠物的名字是:'+pet_name.title()+'.\n')
describe_pet(animal_type='中型')
describe_pet('小型')

#函数的实参和形参，简单的返回值， 多次调用函数复赋值 组成一个列表 for循环遍历列表输出值！
def person(name,age):
    xinxi='这个人叫'+name+','+"年龄是："+age
    return xinxi
person_xinxi=person('aaa','20岁')
person_xinxi1=person('bbb','21岁')
per_xinxi=[person_xinxi,person_xinxi1]
for pers_xinxi in per_xinxi[:]:
    print(pers_xinxi)
 复制代码 隐藏代码# 函数 往字典中添加一个信息组成一个新字典 for 循环遍历所有的字典的键-值最后输出
def person1(name,sex,age=''):
    person1={'n':name,'s':sex}
    if age:
        person1['a']=age #在上面的person1字典中添加一个 'a':age 的字典
        return person1
xinxi=person1('rj','男',age='20')
'''打印字典的所有信息'''
print(xinxi)
'''打印全部的键-值'''
for key,value in xinxi.items():
    print(key)
    print(value)
'''只打印字典中的键'''
for key in xinxi.keys():
    print(key)
'''只打印字典中的值'''
for value in xinxi.values():
    print(value)

# 结合使用函数和while循环
def mingzi(first_name,last_name):
    '''返回一个全部的名字'''
    full_name=first_name+' '+last_name
    return full_name.title()
'''这是有一个无限循环'''
while True:
    print('请输入您的名字')
    f_name=input("请输入您的First_name:")
    if f_name=='tuichu':
        break
    l_name=input("请输入您的Last_name:")
    if l_name=='quxiao':
        break
    '''调用前面定义的函数'''
    suoyou_name=mingzi(f_name,l_name)
    print(suoyou_name)
 复制代码 隐藏代码# 传递列表
def greet_users(names):
    '''向列表中的每一位用户都发出一条简单的问候'''
    for name in names:
        print('Hi',name.title()+'!')
names=['rj','cj','ft']
greet_users(names)

# 在函数中修改列表 while循环移除数据，可用数据，添加到工具，for循环遍历 移除的可用的数据 并 输出修改后的列表数据
che = ["motuo", "qiche", "zixingche", 'huoche']
gongju=[]
while che:
    che3=che.pop()
    print('gongu:'+che3)
    gongju.append(che3)
for che4 in sorted(gongju): #sorted() 临时性abcde 正向或逆向排序
    print(che4)

#传递任意数量的实参 多次调用函数赋值
def make_pizza(*toppings):
    print(toppings)
make_pizza('wuai')
make_pizza('wuai','po','jie','wuaipo','pojie','wuaipojie')

#传递任意数量的实参 多次调用函数赋值 并且循环遍历实参并输出
def make_pizza(*toppings):
    print('这里要输出循环遍历的名字结果：')
    for topping in toppings:
        print('-'+topping)
make_pizza('wuai')
make_pizza('wuai','po','jie','wuaipo','pojie','wuaipojie')

# 结合使用位置实参和任意数量的实参 还嫌匹配位置实参和关键字实参
def make_pizza(size,*toppings):
    print('总共需要'+str(size)+'这里要输出循环遍历的名字结果：')
    for topping in toppings:
        print('-'+topping)
make_pizza(16,'wuai')
make_pizza(12,'wuai','po','jie','wuaipo','pojie','wuaipojie')

1.导入模块

pizza.py 模块

1
2
3
4
复制代码 隐藏代码def make_pizza(size, *toppings):
   print('总共需要' + str(size) + '这里要输出循环遍历的名字结果：')
   for topping in toppings:
       print('-' + topping)

making_pizzas.py import 模块名

1
2
3
 复制代码 隐藏代码import pizza   #导入的模块的名字 pizza
pizza.make_pizza(15,'wuai')
pizza.make_pizza(18,'wuai','po','jie')

2.导入特定的函数

making_pizzas.py from 模块名 import 函数名

1
2
3
 复制代码 隐藏代码from pizza import make_pizza   #导入特定的函数 make_pizza
make_pizza(15,'wuai')
make_pizza(18,'wuai','po','jie')

3.使用as 给函数指定别名

making_pizzas.py from 模块名 import 函数名 as 别名

1
2
3
 复制代码 隐藏代码from pizza import make_pizza as mp   #导入特定的函数 make_pizza 并且指定别名
mp(15,'wuai')
mp(18,'wuai','po','jie')

4.使用as 给模块指定别名

making_pizzas.py import 模块名 as 别名

1
2
3
 复制代码 隐藏代码import pizza as pi   #导入的模块的名字pizza 并且指定别名pi
pi.make_pizza(15,'wuai')
pi.make_pizza(18,'wuai','po','jie')

5.导入模块中所有的函数

making_pizzas.py from 模块名 import *

1
2
3
 复制代码 隐藏代码from pizza import *   #导入模块中所有的函数
make_pizza(15,'wuai')
make_pizza(18,'wuai','po','jie')

8.类

1.创建类和使用类

dog.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
复制代码 隐藏代码class Dog():
   '''一次模拟小狗的简单测试'''
   #init 是一个特殊的方法，开头和结尾都有两个下划线 三个参数 形参self必不可少
   def __init__(self, name, age):
       '''初始化属性name 和 age'''
       self.name = name
       self.age = age

   def sit(self):
       '''模拟小狗被命令时蹲下'''
       print(self.name.title() + 'is now sitting.')

   def roll_over(self):
       '''模拟小狗被命令时打滚'''
       print(self.name.title() + 'rolled over')

2.根据类来创建实例/多个

dog.py

1
2
3
4
 复制代码 隐藏代码my_dog = Dog('gougou', 6)
you_dog = Dog('xiaogou', 7)
print('我的狗的名字叫：' + my_dog.name.title() + '.')
print('它今年已经：' + str(my_dog.age) + '岁了！')

dog.py #调用方法

1
2
3
 复制代码 隐藏代码my_dog = Dog('gougou', 6)
my_dog.sit() #调用sit蹲下方法
my_dog.roll_over() #调用roll_over打滚方法

3.使用类和实例

che.py 属性指定默认的值 和 修改属性的值(直接和自定义函数) 不允许年份比之前要小

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
 复制代码 隐藏代码# 在方法中通过自定义修改函数 修改属性的值
class Che():
    def __init__(self, gongjiao, daba):
        self.gongjiao = gongjiao
        self.daba = daba
        self.year = 9

    def dache(self):
        dache1 = self.gongjiao + self.daba
        return dache1

    def nian(self):
        print('这两个大车的年限是：' + str(self.year) + '年！')

    def update(self, nianfen):
        '''使用修改方法 为年限设置 值'''
        self.year = nianfen
        if nianfen >= self.year:
            self.year = nianfen
        else:
            print('不允许年份比现在设置的值要小！')

gongju1 = Che('公交', '大巴')
print(gongju1.dache())
gongju1.update(8)
gongju1.nian()

9. 继承

che.py

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
 复制代码 隐藏代码# 在方法中通过自定义修改函数 修改属性的值
class Che():
    def __init__(self, gongjiao, daba):
        self.gongjiao = gongjiao
        self.daba = daba
        self.year = 9

    def dache(self):
        dache1 = self.gongjiao + '\t' + self.daba
        return dache1

    def nian(self):
        print('这两个大车的年限是：' + str(self.year) + '年！')

    '''修改属性的值 或 增加属性的值'''

    def update(self, nianfen):
        '''使用修改方法 为年限设置 值'''
        self.year += nianfen
        if nianfen >= self.year:
            self.year = nianfen
        else:
            print('不允许年份比现在设置的值要小！')

gongju1 = Che('公交', '大巴')
print(gongju1.dache())
gongju1.update(10)
gongju1.nian()

# 继承   子类 继承 父类  使用super初始化父类的属性 输出时子类调用父类的函数
class ElectricCar(Che):
    '''还有哪几种车'''

    def __init__(self, gongjiao, daba):
        '''使用super初始化父类的属性'''
        super(ElectricCar, self).__init__(gongjiao, daba)

gongjuzilei = ElectricCar('公交子类', '大巴子类')
print(gongjuzilei.dache()) #子类调用父类的函数 输出

1.给子类定义属性和方法

che.py che为父类 ElectricCar为子类 子类继承父类 即：子类(父类)

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
 复制代码 隐藏代码# 在方法中通过自定义修改函数 修改属性的值
class Che():
    def __init__(self, gongjiao, daba):
        self.gongjiao = gongjiao
        self.daba = daba
        self.year = 9

    def dache(self):
        dache1 = self.gongjiao + '\t' + self.daba
        return dache1

    def nian(self):
        print('这两个大车的年限是：' + str(self.year) + '年！')

    '''修改属性的值 或 增加属性的值'''

    def update(self, nianfen):
        '''使用修改方法 为年限设置 值'''
        self.year += nianfen
        if nianfen >= self.year:
            self.year = nianfen
        else:
            print('不允许年份比现在设置的值要小！')

gongju1 = Che('公交', '大巴')
print(gongju1.dache())
gongju1.update(10)
gongju1.nian()

# 继承   子类继承父类 使用super初始化父类的属性 输出时子类调用父类的函数 给子类定义属性和方法
class ElectricCar(Che):
    '''还有哪几种车'''

    def __init__(self, gongjiao, daba):
        '''使用super初始化父类的属性'''
        super(ElectricCar, self).__init__(gongjiao, daba)
        self.daxiao=70   #定义一个子类特有的属性
    def chedaxiao(self):
        '''打印一条关于车的大小的信息'''
        print('车的大小是：'+str(self.daxiao)+'米')

#给子类的属性进行赋值 
gongjuzilei = ElectricCar('公交子类', '大巴子类')
print(gongjuzilei.dache()) #子类调用父类的函数 输出
gongjuzilei.chedaxiao()   #在子类中给输出这个子类特有的属性值

2.子类重写父类的方法

che.py che为父类 ElectricCar为子类 子类继承父类 即：子类(父类)

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
 复制代码 隐藏代码# 在方法中通过自定义修改函数 修改属性的值
class Che():
    def __init__(self, gongjiao, daba):
        self.gongjiao = gongjiao
        self.daba = daba
        self.year = 9

    def dache(self):
        dache1 = self.gongjiao + '\t' + self.daba
        return dache1

    def nian(self):
        print('这两个大车的年限是：' + str(self.year) + '年！')

    '''修改属性的值 或 增加属性的值'''
    def update(self, nianfen):
        '''使用修改方法 为年限设置 值'''
        self.year += nianfen
        if nianfen >= self.year:
            self.year = nianfen
        else:
            print('不允许年份比现在设置的值要小！')

gongju1 = Che('公交', '大巴')
print(gongju1.dache())
gongju1.update(10)
gongju1.nian()

# 继承   子类继承父类 使用super初始化父类的属性 输出时子类调用父类的函数 给子类定义属性和方法
class ElectricCar(Che):
    '''还有哪几种车'''

    def __init__(self, gongjiao, daba):
        '''使用super初始化父类的属性'''
        super(ElectricCar, self).__init__(gongjiao, daba)
        '''新增两条大小和年份的属性'''
        self.daxiao = 70
        self.nianfen=2

    def chedaxiao(self):
        '''打印一条关于车的大小的信息'''
        print('车的大小是：' + str(self.daxiao) + '米')

    def nian(self):
        print('这个大车的使用年份是：' + str(self.nianfen) + '年！')

    def update(self, nianfen):
        '''修改车子的使用年限'''
        self.nianfen = nianfen

# 通过子类来给 属性传递参数
gongjuzilei = ElectricCar('公交子类', '大巴子类')
print(gongjuzilei.dache())  # 子类调用父类的函数 输出
gongjuzilei.chedaxiao()
gongjuzilei.update(12) #给形参传递年份的信息
gongjuzilei.nian() #子类调用年份的函数 传递相关的年份信息

3.导入类/单个类

car.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 复制代码 隐藏代码# 给属性指定默认的值  定义一个类 在类中定义 几个函数
class Car():
    def __init__(self, qiche, huoche):
        '''初始化描述车的类型'''
        self.qiche = qiche
        self.huoche = huoche
        self.year = 6

    def chexing(self):
        '''定一个车型的函数'''
        message = (self.qiche + '\t' + self.huoche)
        return message.title()

    def nian(self):
        '''定义一个输出车的年份的函数'''
        print('车的年份都是：' + str(self.year) + '年！')

mycar.py

1
2
3
4
5
6
7
8
 复制代码 隐藏代码from car import Car # from 文件名 import 类名
# 为类的形参赋值
my_car = Car('汽车', '火车')
# 调用chexing的函数输出
print(my_car.chexing())
# 修改属性的值 并 调用相关的函数输出
my_car.year = 12
my_car.nian()

4.模块中存储多个类/类继承 导入

car.py

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
 复制代码 隐藏代码# 给属性指定默认的值  定义一个类 在类中定义 几个函数
class Car():
    def __init__(self, qiche, huoche):digits
        '''初始化描述车的类型'''
        self.qiche = qiche
        self.huoche = huoche
        self.year = 6

    def chexing(self):
        '''定一个车型的函数'''
        message = (self.qiche + '\t' + self.huoche)
        return message.title()

    def nian(self):
        '''定义一个输出车的年份的函数'''
        print('车的年份都是：' + str(self.year) + '年！')

# 继承   子类继承父类 使用super初始化父类的属性 输出时子类调用父类的函数 给子类定义属性和方法
# 重写父类的方法 在子类中定义个和父类中同名的方法 Python不会考虑在父类中的方法，只关注在子类中定义的相应方法
class ElectricCar(Car):
    '''还有哪几种车'''

    def __init__(self, gongjiao, daba):
        '''使用super初始化父类的属性'''
        super(ElectricCar, self).__init__(gongjiao, daba)
        self.daxiao = 70
        self.nianfen = 2

    def chedaxiao(self):
        '''打印一条关于车的大小的信息'''
        print('车的大小是：' + str(self.daxiao) + '米')

    # 子类重写父类函数
    def nian(self):
        print('这个大车的使用年份是：' + str(self.nianfen) + '年！')

    # 子类重写父类的函数
    def update(self, nianfen):
        '''修改车子的使用年限'''
        self.nianfen = nianfen

my_electric_car.py 从一个模块中导入多个类 格式：from 模块名 import 类名,类名 或者 *

1
2
3
4
5
6
7
8
9
10
11
 复制代码 隐藏代码from car import Car,ElectricCar

# 传递实参的参数给形参 并输出传递的参数
my_tesla = ElectricCar('公交', '大巴')
print(my_tesla.chexing())
# 修改属性的值 并调用函数输出相关的信息
my_tesla.daxiao = 80
print(my_tesla.chedaxiao())
# 修改属性的值，并调用函数输出相关的信息
my_tesla.nianfen = 5
print(my_tesla.nian())

5.导入整个模块/模块中所有的类

my_cars.py import 模块名 from 模块名 import 所有的类

1
2
 复制代码 隐藏代码import car
from car import *

6.Python 标准库

字典让你能够和信息关联起来，但是不记录添加键值对的顺序。创建字典并记录键值对中的数据可以使用模块 collections 中的 OrderedDict类。OrderedDict实例几乎与字典相同，区别只是在于记录键-值对的顺序！

1
2
3
4
5
6
7
8
9
10
11
 复制代码 隐藏代码from collections import OrderedDict  # 导入一个模块中的函数

favorivte_languages = OrderedDict()  # 将类赋值给favorivte_languages
'''往favorivte_languages中添加字典信息'''
favorivte_languages['che'] = 'qiche'
favorivte_languages['che1'] = 'mache'
favorivte_languages['che2'] = 'huoche'
favorivte_languages['che3'] = 'kache'
# for循环遍历输出类的字典信息
for che, mingzi in favorivte_languages.items():
    print('这些' + che.title() + '\t' + '叫：' + mingzi.title() + '.')

10.文件和异常

1.读取整个文件 read()

pi_digits.txt

1
2
3
复制代码 隐藏代码3.1415926535
 8979323846
 2643383279

file_reader.py 读取整个文件的格式是： with open(‘文件的名字’) as file_object:

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
 复制代码 隐藏代码# 相对文件路径 （优先使用）
with open('pi_digits.txt') as file_object:
    contents = file_object.read()
    print(contents.rstrip())  # 多出一个空行的情况下可以使用 rstrip() 来去除字符串后面的空白

# 将文件放在项目文件夹中 相对文件路径  （优先使用）
with open('text_files\pi_digits.txt') as file_object:
    shuchu = file_object.read()
    print(shuchu)

# 将文件放在电脑桌面上  绝对文件路径
file_path = 'C:\\Users\lenovo\Desktop\pi_digits.txt'
with open(file_path) as file_object:
    print(file_object.read())

# 逐行 读取文件的信息
file_path = 'pi_digits.txt'
with open(file_path) as file_object:
    for line in file_object:
        print(line.rstrip())  # 多出一个空行的情况下可以使用 rstrip() 来去除字符串后面的空白

# 逐行 读取文件的信息 使用readlines()
file_path = 'pi_digits.txt'
with open(file_path) as file_object:
    lines = file_object.readlines()
    for line in lines:
        print(line.rstrip())  # 多出一个空行的情况下可以使用 rstrip() 来去除字符串后面的空白

2.使用文件的内容 读取/拼接/长度

pi_string.py

1
2
3
4
5
6
7
8
9
 复制代码 隐藏代码# 逐行 读取文件的信息 使用readlines()
file_path = 'pi_digits.txt'
with open(file_path) as file_object:
    lines = file_object.readlines()  # 读取文件中每行的信息
pi_string = ''  # 创建一个字符串
for line in lines:  # 遍历读取到的文件的每行信息 存储到line中
    pi_string += line.strip()  # 读取到的每行信息+创建的字符串  并用strip()去除两端的空格
print(pi_string)  # 输出拼接之后的信息
print(len(pi_string))  # 输出拼接之后的信息的字符串长度

3.读取一个百万位的大型文件

pi_string.py

1
2
3
4
5
6
7
8
9
 复制代码 隐藏代码# 逐行 读取文件的信息 使用readlines()
file_path = 'pi_digits.txt'
with open(file_path) as file_object:
    lines = file_object.readlines()  # 读取文件中每行的信息
pi_string = ''  # 创建一个字符串
for line in lines:  # 遍历读取到的文件的每行信息 存储到line中
    pi_string += line.strip()  # 读取到的每行信息+创建的字符串  并用strip()去除两端的空格
print(pi_string[:9]+'...')  # 输出拼接之后的信息 只输出列表中的前9位 如果输出百万位 把9改为1000000
print(len(pi_string))  # 输出拼接之后的信息的字符串长度

4.写入到空文件(多行)/附加/读取

pi_string.py

1
2
3
4
 复制代码 隐藏代码# 写入文件 执行完之后 文件目录中 会生成一个xieru.txt的文件 内容就是‘易瑞杰正在学习Python’
file_path='xieru.txt'
with open(file_path,'w') as file_object:
    file_object.write('rj正在学习Python')

pi_string.py 

1
2
3
4
5
6
7
8
9
10
11
12
 复制代码 隐藏代码# 写入文件 在读取写入的文件内容和文件长度
file_path = 'wenjian.txt'
with open(file_path, 'w') as file_object:  # w:表示写入(Write)到这个文件中
    file_object.write('rj正在学习Python' + '\n')
    file_object.write('rj正在学习Python1' + '\n')
with open(file_path, 'a') as file_object:  # a:表示附加(Attach)到这个文件中
    file_object.write('rj正在学习Python' + '\n')
with open(file_path, 'r') as file_object:  # r:表示读取(read)这个文件的内容
    lines = file_object.readlines()
    for line in lines:
        print(line.strip())
        print(len(line))

pi_string.py

1
2
3
4
5
 复制代码 隐藏代码# 提示用户输入自己的姓名 再将用户输入的姓名写入到文件中输出
file_path = 'tishishuru.txt'
with open(file_path, 'w') as file_object:  # w:表示写入(Write)到这个文件中
    message = input('请输入您的名字：')
    file_object.write(message)

division.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 复制代码 隐藏代码# 异常 division by zero
print(5/0)
 复制代码 隐藏代码# 异常 division by zero（ZeroDivisionError）
'''try-except 的代码块包裹快捷键是 Ctrl+Alt+T'''
try:
    print(5/0)
except ZeroDivisionError:
    print('你的被除数不能为零！')
 复制代码 隐藏代码# 分析文本 拆分字符串 for循环遍历输出
title = "r j study Python"
print(title.split())  #遍历根据空格拆分 输出的是一个列表
fenxi = title.split()  # 以空格为分隔符拆分文本
for wenben in fenxi:  # 遍历根据空格拆分之后的文本 并输出
    print(wenben)

division.py 使用多个文件

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
 复制代码 隐藏代码# 定义函数 排除异常 读取文件 拆分文件内容 计算内容长度 写入到新的文件中
def count_words(filename):
    try:
        with open(filename, 'r') as file_object:
            contents = file_object.read()
    except FileNotFoundError:
        print('文件' + filename + '是不存在的！')
    else:
        words = contents.split()
        for wenben in words:
            print(wenben)        #遍历输出拆分之后的每条信息
        num_words=(len(words))
        print('这个文件是真是存在的'+filename+'文件中的内容的长度是：'+str(num_words))

filename = 'alice.txt'
count_words(filename)
 复制代码 隐藏代码# 定义函数 排除异常 读取文件(多个文件) 拆分文件内容 计算内容长度 写入到新的文件中
def count_words(filename):
    try:
        with open(filename, 'r') as file_object:
            contents = file_object.read()
    except FileNotFoundError:
        print('文件' + filename + '是不存在的！')
    else:
        words = contents.split()
        for wenben in words:
            print(wenben)
        num_words=(len(words))
        print('这个文件是真是存在的'+filename+'文件中的内容的长度是：'+str(num_words))

'''当其中的某一文件不存在时丝毫不影响，其他的文件'''
filenames = ['alice1.txt','alice2.txt','alice3.txt','alice4.txt']
for filename in filenames:
    count_words(filename)

5.存储数据

number_reader.py json.dump()和json.load()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 复制代码 隐藏代码import json

# 将列表数据存储在number.json 文件中
number = [2, 3, 4, 5, 7, 11, 13]
filename = 'number.json'
with open(filename, 'w') as f_obj:
    json.dump(number, f_obj)  # json.dump用来存储。    number：要存入json文本的数据源.   f_obj:存入到的文件的位置
    print('数据存储到' + filename + '完成！')

# 读取前面写入到number.json文件的数据内容
filename = 'number.json'
with open(filename, 'r') as f_obj:
    numbers = json.load(f_obj)  # json.load用来读取。  f_obj:读取的数据源的位置
    print(numbers)
for number in numbers:  # for循环遍历输出读取到的文件中的每条列表中的数据 并 打印输出
    print(number)

remember_me.py 保存和读取用户输入的数据

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
 复制代码 隐藏代码import json

# 保存用户输入时生成的数据到json文件中
username = input("请输入您的名字：")
filename = 'username.json'
with open(filename, 'w') as f_obj:
    json.dump(username, f_obj)  # json.dump用来存储。   username：要存入json文本的数据源.   f_obj:存入到的文件的位置 username.json
    print('这个人的名字叫：' + username)

# 读取用户输入存储到json中的数据
filename = 'username.json'
with open(filename, 'r') as f_obj:
    username = json.load(f_obj)  # json.load用来读取。  f_obj:读取的数据源的位置
    print('在文件中读取到的信息是：' + username)
 复制代码 隐藏代码import json

# json.dump()  json.load() try-except-else 的组合使用
# 如果以前存储了用户名就加载它，否则就提示用户输入用户名并存储它
filename = 'username.json'
try:
    with open(filename, 'r') as f_obj:
        username = json.load(f_obj)  # json.load用来读取。  f_obj:读取的数据源的位置
        print('在文件中读取到的信息是：' + username)
except FileNotFoundError:
    # 保存用户输入时生成的数据到json文件中
    username = input("请输入您的名字：")
    with open(filename, 'w') as f_obj:
        json.dump(username, f_obj)  # json.dump用来存储。   username：要存入json文本的数据源.   f_obj:存入到的文件的位置 username.json
        print('这个人的名字叫：' + username)
else:
    print('欢迎你：' + username + '!')

6.重构

remember.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 复制代码 隐藏代码import json

# json.dump()  json.load() try-except-else 的组合使用
# 如果以前存储了用户名就加载它，否则就提示用户输入用户名并存储它
def greet_user():
    '''问候用户，并指出其名字'''
    filename = 'username.json'
    try:
        with open(filename, 'r') as f_obj:
            username = json.load(f_obj)  # json.load用来读取。  f_obj:读取的数据源的位置
            print('在文件中读取到的信息是：' + username)
    except FileNotFoundError:
        # 保存用户输入时生成的数据到json文件中
        username = input("请输入您的名字：")
        with open(filename, 'w') as f_obj:
            json.dump(username, f_obj)  # json.dump用来存储。   username：要存入json文本的数据源.   f_obj:存入到的文件的位置 username.json
            print('这个人的名字叫：' + username)
    else:
        print('欢迎你：' + username + '!')

greet_user()

remember.py

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
 复制代码 隐藏代码import json

# json.dump()  json.load() try-except-else 的组合使用
# 如果以前存储了用户名就加载它，否则就提示用户输入用户名并存储它
# 定义函数 get_stored_username 读取已经存在的用户信息
def get_stored_username():
    '''问候用户，并指出其名字'''
    filename = 'username.json'
    try:
        with open(filename, 'r') as f_obj:
            username = json.load(f_obj)  # json.load用来读取。  f_obj:读取的数据源的位置
            print('在文件中读取到的信息是：' + username)
    except FileNotFoundError:
        return None
    else:
        return username

# 读取不到已经存在的信息 使用greet_user函数 提示用户输入信息 并写入到json文件中
def greet_user():
    username = get_stored_username()
    if username:
        print("这个人的名字叫：" + username)
    else:
        username = input('请输出您的名字：')
        filename = 'username.json'
        with open(filename, 'w') as f_obj:
            json.dump(username, f_obj)
            print('用户输入的数据是：' + username)

greet_user()
 复制代码 隐藏代码import json

# json.dump()  json.load() try-except-else 的组合使用
# 如果以前存储了用户名就加载它，否则就提示用户输入用户名并存储它
# 定义函数 get_stored_username 读取已经存在的用户信息
def get_stored_username():
    '''问候用户，并指出其名字'''
    filename = 'username.json'
    try:
        with open(filename, 'r') as f_obj:
            username = json.load(f_obj)  # json.load用来读取。  f_obj:读取的数据源的位置
            print('在文件中读取到的信息是：' + username)
    except FileNotFoundError:
        return None
    else:
        return username

def get_new_username():
    '''提示用户输入姓名'''
    username = input('请输出您的名字：')
    filename = 'username.json'
    with open(filename, 'w') as f_obj:
        json.dump(username, f_obj)
    return username

# 读取到已经存在的信息就调用get_stored_username函数并输出
# 读取不到已经存在的信息 调用get_new_username函数 提示用户输入信息 并写入到username.json文件中
def greet_user():
    username = get_stored_username()
    if username:
        print("这个人的名字叫：" + username)
    else:
        username = get_new_username()
        print('用户输入的数据是：' + username)

greet_user()

11.测试代码

1.测试函数

name_function.py

1
2
3
4
复制代码 隐藏代码def get_formatted_name(first, last):
   '''生成整洁的名字'''
   full_name = first + ' ' + last
   return full_name.title()

name.py from 模块名 import 函数名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 复制代码 隐藏代码from name_function import get_formatted_name

# from name_function import *
# from name_function import get_formatted_name as gfn

print('输入‘q’就是退出程序！')
while True:
    first = input('请输入你的第一个名字：')
    if first == 'q':
        break
    last = input('请输入你的最后一个名字：')
    if last == 'q':
        break
    formatted_name = get_formatted_name(first, last)
    print('\t用户输入的两个名字结果是：' + formatted_name)

2.单元测试和测试用例 / 可通过测试 / 添加新测试

name_function.py

1
2
3
4
复制代码 隐藏代码def get_formatted_name(first, last):
   '''生成整洁的名字'''
   full_name = first + ' ' + last
   return full_name.title()

test_name_function.py

1
2
3
4
5
6
7
8
9
10
11
12
13
 复制代码 隐藏代码import unittest
from name_function import get_formatted_name

class NamesTestCase(unittest.TestCase):
    '''测试 name_function.py'''

    def test_first_last_name(self):
        '''看处理的信息 是否断言等于(assertEqual) 预期的输出信息'''
        formatted_name = get_formatted_name('wuai', 'rj')
        self.assertEqual(formatted_name, 'Wuai Rj')

if __name__ == '__main__':
    unittest.main()

添加新测试

name_funciton.py

1
2
3
4
复制代码 隐藏代码def get_formatted_name(first, last):
   '''生成整洁的名字'''
   full_name = first + ' ' + last
   return full_name.title()

test_name_function.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 复制代码 隐藏代码import unittest
from name_function import get_formatted_name

class NamesTestCase(unittest.TestCase):
    '''测试 name_function.py'''

    def test_first_last_name(self):
        '''看处理的信息 是否断言等于(assertEqual) 预期的输出信息'''
        formatted_name = get_formatted_name('wuai', 'rj')
        self.assertEqual(formatted_name, 'Wuai Rj')
    def xin_test_first_last_name(self):
        '''看处理的信息 是否断言等于(assertEqual) 预期的输出信息'''
        formatted_name = get_formatted_name('rj', 'wuai')
        self.assertEqual(formatted_name, 'Rj Wuai')

if __name__ == '__main__':
    unittest.main()

3.测试类

测试中常用的6种的断言方法

1
2
3
4
5
6
复制代码 隐藏代码        self.assertEqual(a,b)                    #核实a==b
       self.assertNotEqual(a,b)                 #核实a!=b
       self.assertTrue(x)                       #核实x为True
       self.assertFalse(x)                      #核实x为false
       self.assertIn(item,list)                 #核实item在list中
       self.assertNotIn(item,list)              #核实item不在list中

survey.py #一个要测试的类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
复制代码 隐藏代码class AnonymousSurvey():
   '''收集匿名调查问卷的答案'''

   def __init__(self, question):
       '''存储一个问题，并未存储答案做准备'''
       self.question = question
       self.responses = []

   def show_question(self):
       '''显示调查问卷'''
       print(self.question)

   def store_response(self, new_response):
       '''存储单份调查问卷'''
       self.responses.append(new_response)

   def show_results(self):
       '''显示收集到的所有答卷'''
       print('调查的结果是:')
       for response in self.responses:
           print('-' + response)

language_survey.py #一个要使用测试的类的类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 复制代码 隐藏代码from survey import AnonymousSurvey

# 定义一个问题并创建一个表示调查的AnonymousSurvey对象
question = 'what language did you first learn to speak?'
my_survey = AnonymousSurvey(question)

# 显示问题并存储答案
my_survey.show_question()
print("用户输入'q'就可以退出")
while True:
    response = input('Language:')
    if response == 'q':
        break
    my_survey.store_response(response)

# 显示要调查的结果
print('很感谢你参与这个调查！')
my_survey.show_results()

测试AnonymousSurvey类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 复制代码 隐藏代码import unittest
from survey import AnonymousSurvey

# 子类继承父类 父类是测试类
class TestAnonymousSurvey(unittest.TestCase):
    '''针对AnonymousSurvey类的测试'''

    def test_store_single_response(self):
        '''测试单个答案会被妥善的存储'''
        question = 'what language did you first learn to speak?'
        my_survey = AnonymousSurvey(question)
        my_survey.store_response('English')
        self.assertIn('English', my_survey.responses)  # 核实Englishm是否在my_survey.responses中

if __name__ == '__main__':
    unittest.main()

test_survey.py for遍历测试类中的答案列表 方法 setUp()

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
 复制代码 隐藏代码import unittest
from survey import AnonymousSurvey

# 子类继承父类 父类是测试类
class TestAnonymousSurvey(unittest.TestCase):
    '''针对AnonymousSurvey类的测试'''

    def setUp(self):
        '''创建一个调差对象和一组答案，供使用的测试方法使用'''
        question = 'what language did you first learn to speak?'
        self.my_survey = AnonymousSurvey(question)
        self.response = ['English', 'Spanish', 'Mandarin', 'Chinese']

    def test_store_single_response(self):
        '''测试单个答案会被妥善的存储'''
        self.my_survey.store_response(self.response[0])
        self.assertIn(self.response[0], self.my_survey.responses)  # 核实Englishm是否在my_survey.responses中

    def test_store_three_responses(self):
        '''测试三个答案会被妥善的存储'''
        for response in self.response:
            self.my_survey.store_response(response)
        for response in self.response:
            self.assertIn(response, self.my_survey.responses)

if __name__ == '__main__':
    unittest.main()

12.写一个简单的程序/打包为exe并运行

shuzi.py 创建1~100的一个数字列表，存储在文件shuzi.txt中，并读取显示在控制台！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 复制代码 隐藏代码print('创建1~100的一个数字列表，存储在文件shuzi.txt中，并读取显示在控制台！')

def kaishi():
    message = input('请用户输入开始或者结束(Y/N):')
    if message == 'Y':
        # 创建一个1~100的数字列表 并输出到文件
        print('恭喜你！文件内容输出已成功！')
        number = list(range(1, 101))
        print(number)
        file_name = '1~100.txt'
        with open(file_name, 'w') as file_object:
            for shuzi in number:
                file_object.write(str(shuzi) + '\n')
        with open(file_name, 'r') as file_object:
            line = file_object.readlines()
            for shuzi in line:
                print(shuzi.strip())
    elif message == 'N':
        print('很抱歉，您选择了退出！拜拜!')
    else:
        print('注意！！！ 请按照指令输入哦！Y或者N ')
        kaishi()

kaishi()

1.打包教程

打包生成参考链接1 打包生成参考链接2

win+R 输入cmd 进入命令行窗口 执行 pip install Pyinstaller 安装打包的插件

之后cd 到要打包的文件项目的路径下：D:\SoftwareProject\PyCharmProject\peoject1

也可以在文件项目的窗口路径前直接 添加 cmd D:\SoftwareProject\PyCharmProject\peoject1 敲回车进入

在cmd 窗口中执行命令 Pyinstaller -F test(要打包的文件名).py

Pyinstaller -F 文件名.py //打包exe

Pyinstaller -F -w 文件名.py //不带控制台的打包

Pyinstaller -F -i xx.ico 文件名.py //打包指定exe图标打包

出现completed successfully就成功了。

生成的exe文件在dist里，这个exe文件单独拿出来放在任何的位置都可以运行。