Jetbrains系列软件常用快捷键及Python编程从入门到实践学习总结
本帖最后由 佚名RJ 于 2020-12-26 14:10 编辑**Jetbrains系列软件常用快捷键**及**《Python编程从入门到实践》袁国忠 译P1~P200**
之前两天在学习时做的笔记总结 在这里也记录一下，方便以后查阅，同时也希望能帮助到更多的童鞋！
## 一、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.基本数据类型的运算
```python
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.title())#首字母大写
print(shenghuo.upper()) #全部字母大写
print(shenghuo.lower()) #全部字母小写
print(shenghuo.lstrip()) #去除字符串前面的空白
# 访问列表的元素于去除空格和拼接字符的混合使用
print(shenghuo[-1])
print(shenghuo[-2])
print("一天中要先" + shenghuo + "然后再" + shenghuo[-1].lstrip() + "继续再" + shenghuo + "最后再" + shenghuo[-2])
# 修改 添加 删除 元素
che = ["motuo", "qiche", "zixingche", 'huoche']
print(che)
# 修改
che = "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
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 =
print(max(number))
print(min(number))
print(sum(number))
# 对数字列表解析 列表中每个数的平方赋值给message
message =
print(message)
# 列表的一部分 切片
che = ["motuo", "qiche", "zixingche", 'huoche']
print(che)
print(che)
print(che[:4])# 没有指定一个开头的索引，默认从0开始
print(che)# 没有指定一个结尾的索引，默认到最后结束
# 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)
print(yuanzu)
# 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之禅
```python
import this
```
### 3.Python关键字
```python
# 输出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 ()[]{}区别
**() 表示元组**
```python
# 元组：Python将不能修改的值称为不可变的，而不可变的列表被称为元组！ 不能修改的是元素，而变量是可以修改的
# 定义元组遍历元组中的所有的值
yuanzu = (100, 50)
print(yuanzu)
print(yuanzu)
# 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)
```
**[]表示列表**
```python
# 组织列表 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))
```
**{}大括号表示字典**
```python
# Python字典{} 相当于Java中的键值对
che = {"motuo":'motuoche', 'huoche':5}
print(che['motuo'])
print(che['huoche'])
```
### 5.字典和列表(嵌套)使用
```python
# 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 =
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循环
```python
# 用户输入和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)
```
```python
# 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=respons
repeat=input('还有人要参与调查吗？(yes/no)')
if repeat=='no':
active=False
for name,response in responses.items():
print(name+'\t'+response)
```
### 7.函数
```python
# 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=
for pers_xinxi in per_xinxi[:]:
print(pers_xinxi)
```
```python
# 函数 往字典中添加一个信息组成一个新字典 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)
```
```python
# 传递列表
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 模块
```python
def make_pizza(size, *toppings):
print('总共需要' + str(size) + '这里要输出循环遍历的名字结果：')
for topping in toppings:
print('-' + topping)
```
> making_pizzas.py import 模块名
```python
import pizza #导入的模块的名字 pizza
pizza.make_pizza(15,'wuai')
pizza.make_pizza(18,'wuai','po','jie')
```
#### 2.导入特定的函数
> making_pizzas.py from 模块名 import 函数名
```python
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 别名
```python
from pizza import make_pizza as mp #导入特定的函数 make_pizza 并且指定别名
mp(15,'wuai')
mp(18,'wuai','po','jie')
```
#### 4.使用as 给模块指定别名
> making_pizzas.py import 模块名 as 别名
```python
import pizza as pi #导入的模块的名字pizza 并且指定别名pi
pi.make_pizza(15,'wuai')
pi.make_pizza(18,'wuai','po','jie')
```
#### 5.导入模块中所有的函数
> making_pizzas.py from 模块名 import *
```python
from pizza import * #导入模块中所有的函数
make_pizza(15,'wuai')
make_pizza(18,'wuai','po','jie')
```
### 8.类
#### 1.创建类和使用类
> dog.py
```python
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
```python
my_dog = Dog('gougou', 6)
you_dog = Dog('xiaogou', 7)
print('我的狗的名字叫：' + my_dog.name.title() + '.')
print('它今年已经：' + str(my_dog.age) + '岁了！')
```
> dog.py #调用方法
```python
my_dog = Dog('gougou', 6)
my_dog.sit() #调用sit蹲下方法
my_dog.roll_over() #调用roll_over打滚方法
```
#### 3.使用类和实例
> che.py 属性指定默认的值 和 修改属性的值(直接和自定义函数) 不允许年份比之前要小
```python
# 在方法中通过自定义修改函数 修改属性的值
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
```python
# 在方法中通过自定义修改函数 修改属性的值
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为子类 子类继承父类 即：子类(父类)
```python
# 在方法中通过自定义修改函数 修改属性的值
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为子类 子类继承父类 即：子类(父类)
```python
# 在方法中通过自定义修改函数 修改属性的值
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
```python
# 给属性指定默认的值定义一个类 在类中定义 几个函数
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
```python
from car import Car # from 文件名 import 类名
# 为类的形参赋值
my_car = Car('汽车', '火车')
# 调用chexing的函数输出
print(my_car.chexing())
# 修改属性的值 并 调用相关的函数输出
my_car.year = 12
my_car.nian()
```
#### 4.模块中存储多个类/类继承 导入
> car.py
```python
# 给属性指定默认的值定义一个类 在类中定义 几个函数
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类名,类名 或者 *
```python
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所有的类
```python
import car
from car import *
```
#### 6.Python 标准库
> 字典让你能够和信息关联起来，但是不记录添加键值对的顺序。创建字典并记录键值对中的数据可以使用模块 collections 中的 OrderedDict类。OrderedDict实例几乎与字典相同，区别只是在于记录键-值对的顺序！
```python
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
```txt
3.1415926535
8979323846
2643383279
```
> file_reader.py 读取整个文件的格式是： with open('文件的名字') as file_object:
```python
# 相对文件路径 （优先使用）
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
```python
# 逐行 读取文件的信息 使用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
```python
# 逐行 读取文件的信息 使用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
```python
# 写入文件 执行完之后 文件目录中 会生成一个xieru.txt的文件 内容就是‘易瑞杰正在学习Python’
file_path='xieru.txt'
with open(file_path,'w') as file_object:
file_object.write('rj正在学习Python')
```
> pi_string.py
```python
# 写入文件 在读取写入的文件内容和文件长度
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
```python
# 提示用户输入自己的姓名 再将用户输入的姓名写入到文件中输出
file_path = 'tishishuru.txt'
with open(file_path, 'w') as file_object:# w:表示写入(Write)到这个文件中
message = input('请输入您的名字：')
file_object.write(message)
```
> division.py
```python
# 异常 division by zero
print(5/0)
```
```python
# 异常 division by zero（ZeroDivisionError）
'''try-except 的代码块包裹快捷键是 Ctrl+Alt+T'''
try:
print(5/0)
except ZeroDivisionError:
print('你的被除数不能为零！')
```
```python
# 分析文本 拆分字符串 for循环遍历输出
title = "r j study Python"
print(title.split())#遍历根据空格拆分 输出的是一个列表
fenxi = title.split()# 以空格为分隔符拆分文本
for wenben in fenxi:# 遍历根据空格拆分之后的文本 并输出
print(wenben)
```
> division.py 使用多个文件
```python
# 定义函数 排除异常 读取文件 拆分文件内容 计算内容长度 写入到新的文件中
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)
```
```python
# 定义函数 排除异常 读取文件(多个文件) 拆分文件内容 计算内容长度 写入到新的文件中
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()
```python
import json
# 将列表数据存储在number.json 文件中
number =
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 保存和读取用户输入的数据
```python
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)
```
```python
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
```python
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
```python
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()
```
```python
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
```python
def get_formatted_name(first, last):
'''生成整洁的名字'''
full_name = first + ' ' + last
return full_name.title()
```
> name.py from 模块名 import 函数名
```python
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
```python
def get_formatted_name(first, last):
'''生成整洁的名字'''
full_name = first + ' ' + last
return full_name.title()
```
> test_name_function.py
```python
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
```python
def get_formatted_name(first, last):
'''生成整洁的名字'''
full_name = first + ' ' + last
return full_name.title()
```
> test_name_function.py
```python
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种的断言方法
```python
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 #一个要测试的类
```python
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 #一个要使用测试的类的类
```python
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类**
```python
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()
```python
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)
self.assertIn(self.response, 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中，并读取显示在控制台！
```python
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](https://www.cnblogs.com/lyy135146/p/11867754.html) [打包生成参考链接2](https://www.cnblogs.com/ZFJ1094038955/p/13375740.html)
win+R 输入cmd 进入命令行窗口 执行 `pip install Pyinstaller` 安装打包的插件
之后cd 到要打包的文件项目的路径下：`D:\SoftwareProject\PyCharmProject\peoject1`
也可以在文件项目的窗口路径前直接 添加 `cmd D:\SoftwareProject\PyCharmProject\peoject1 ``敲回车进入`
在cmd 窗口中执行命令 `Pyinstaller -Ftest(要打包的文件名).py`
> Pyinstaller -F 文件名.py //打包exe
>
> Pyinstaller -F -w 文件名.py //不带控制台的打包
>
> Pyinstaller -F -i xx.ico 文件名.py //打包指定exe图标打包
出现completed successfully就成功了。
生成的exe文件在dist里，这个exe文件单独拿出来放在任何的位置都可以运行。 win+R 输入cmd 进入命令行窗口 ghoob321 发表于 2020-12-26 14:11
win+R 输入cmd 进入命令行窗口
老铁这么说没毛病吧！哈哈 这么详细，真是厉害
感谢分享，真是太棒了！~~向你学习 谢谢分享Python的经验 最近也在学，感谢分享！ 大佬优秀啊！太赞了{:301_988:} 谢谢分享！ 楼主太棒了
页:
[1]
2