第一章 Python简介
1. Python起源
- 「Python」是由 吉多 在1989年发明的一个解释程序
- 「Python」的中文意思是 :蟒蛇
- 「Python」是一门解释型语言,无需编译
- 一般情况下,开发相同功能,「Python」的代码量是「java」的「1/5」左右
- 现有版本:
- 「Python2」:最初发布于2001年
- 「Python3」:最初发布于2008年,最新的版本
- 格言:Life is short ,you need Python!(人生苦短,我用Python!)
吉多范罗苏姆
2. Python的应用
- 云计算:云服务器
- web开发:豆瓣,知乎,YouTube
- 人工智能:语音助手,用户行为分析
- 自动化测试:编写自动化测试脚本
附云服务器管理界面图片
3. Python的优势
- 开源,免费
- 易学
- 可移植性强(windows,Linux,MacOs)
-
第二章 安装Python
1. 下载Python安装包
进入官方网站:https://www.python.org
点击Download,选择Windows系统版本,下载带有 Windows,64,exe 字眼的安装包
2. 安装
2.1 安装
2.2 验证Python
打开命令行窗口,输入:「Python」
- 如能看到「Python」版本号,表示安装成功
- 如果提示「Python不是内部或外部命令」,则需要手动配置环境变量,在系统变量path中添加如下路径
C:\Python38\Scripts\;C:\Python38\
2.3 第一个Python程序
在Python交互模式中输入:
这行代码的意思是:在屏幕上打印“你好世界”print("Helloworld")
3. 设置国内下载源
pip默认使用国外安装源,导致安装其他包时,下载速度过慢或者出错
所以,推荐使用国内安装源
python官方源:https://pypi.org 清华:https://pypi.tuna.tsinghua.edu.cn/simple 阿里云:http://mirrors.aliyun.com/pypi/simple/ 中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/ 华中理工大学:http://pypi.hustunique.com/ 山东理工大学:http://pypi.sdutlinux.org/
豆瓣:http://pypi.douban.com/simple/
解决办法1(临时):
# 在下载时临时指定安装源
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名
解决办法2(永久):
Windows
1.新建一个pip目录:C:\user\xxx\pip
2.新建一个pip.ini
# 内容如下
[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
[install]
trusted-host=mirrors.aliyun.com
4. pip导出所有模块
pip freeze>D:\requirements.txt
第三章 安装Pycharm
1. 下载pycharm安装包
- 进入官网:https://www.jetbrains.com/pycharm/
- 下载Community版本,社区版,免费
2. 创建项目
3. 基本布局
4. 新建Python文件
5. 设置字体
6. 配置解释器
在pycharm
中一定要配置好自己安装的「Python」环境的解释器,不然后续自己安装的其他模块将无法使用
7. 设置快捷键
第四章 注释
1. 定义
- 注释是用来解释说明代码的作用的
-
2. 单行注释
单行注释用 # 表示
-
3. 多行注释
多行注释用 一对三单引号/双引 号示
-
4. 快速注释快捷键
按一次 Ctrl + / 快速注释
- 再按一次,取消注释
5. 关于编码规范
Python PEP 8规范中文版本地址:https://zh-google-styleguide.readthedocs.io/en/latest/google-python-styleguide/python_style_rules/第五章 基础数据类型
在真正开始写程序之前,你要知道程序的作用是什么?
程序真正的作用是 处理数据 。数据的种类有很多,我们在手机、电脑等其他设备行看到的文字、数字、音视频等都是数据。
这些数据都是由程序来处理并显示到屏幕上的。
虽然数据的中类形形色色,并且看起来比较复杂,但是在编程时,他们实际上都是由一些非常基本的数据形式(或经过组合)来表示。
在Python中,基本的数据类型有如下这些:
# 整数 int
# 可以使用type去查看数据的类型
print(type(0))
print(type(-1))
print(type(3))
# 浮点数 float
print(type(0.0))
print(type(-0.1))
print(type(0.1))
# 字符串 string str
print(type("x"))
print(type("")) # 空字符串
print(type('')) # 单引号也可以 "i'm ok"
# 布尔值 bool
print(type(True)) # 真
print(type(False)) # 假
# 空值 None
print(type(None)) # None!=0 用来占位
第六章 变量
1. 定义
「推荐的变量命名方式」:
- 见名知意,使用具有固定意义的单词
- 驼峰命名法
- 大驼峰:每个单词首字母都要大写(FirstLove)
- 小驼峰:从第二个单词开始,首字母大写(firstLove)
- 使用下划线连接:first_love
3. 变量的赋值方式
3.1 普通赋值
将右边的值给左边的变量:a = 13.2 序列解包赋值
在一行代码中同时给多个变量赋值,按照位置关系对应:a,b = 1,23.3 链式赋值
在一行代码中同时给多个变量赋同一个值:a = b = c = 1如何查看系统关键字?
import keyword # 导包
print(keyword.kwlist) # 打印系统关键字
第七章 运算符
1. 基础运算符
运算符 | 描述 | 实例 |
---|---|---|
+ | 加 | 10 + 20 = 30,还可以进行字符串拼接 |
- | 减 | 10 - 20 = -10 |
* | 乘 | 10 * 20 = 200,还可以复制字符串 |
/ | 除 | 10 / 20 = 0.5,注意结果为浮点数 |
// | 取整除 | 返回除法的整数部分(商) 9 // 2 输出结果 4 |
% | 取余数 | 返回除法的余数 9 % 2 = 1 |
** | 幂 | 又称次方、乘方,2 ** 3 = 8 |
a, b = 1, 2
print(a + b)
print(a - b)
print(a * b)
print(a / b)
# 使用加号可以拼接字符串
print('abc' + '123')
# 使用乘法可以复制字符串
print('abc' * 10)
# 在python3中,两个整数相除,结果必定为浮点数
print(4 / 2)
print(int(4 / 2)) # 使用int()可以将数据转换成整数类型
2. 复合赋值
加法复合赋值
a = 2
a += 1 # 自增
print(a) # a = a + 1 = 2 + 1 = 3
3. 逻辑运算符
运算符 | 描述 | 示例 |
---|---|---|
and | 和,并且 | True and True,结果为True |
or | 或者 | True or False,结果为True |
not | 非 | not True,结果为False |
print(True and False) # and 有一个假,结果为假
print(True and True) # 两边为真,结果为真
print(True or False) # or 有一个真,结果为真
print(not True) # not 非真即假
print(not False) # 非假即真
4. 比较运算符
运算符 | 描述 | 示例 |
---|---|---|
> | 大于 | 3>2,返回True |
< | 小于 | 3<2,返回False |
>= | 大于或等于 | 2>=2,返回True |
<= | 小于或等于 | 1<=2,返回True |
!= | 不等于 | 3!=2,返回True |
== | 等等于 | 3==2,返回False |
5. 运算符的优先级
永远记住先算括号内,再算括号外
第八章 字符串(Str)
1. 定义
2. 特点
- 有序
- 不可变
不可变图解
3. 字符串的索引和取值
字符串的索引从
0
开始
字符串取值:
根据索引来取值
a[0] # 取出字母H
a[-1] # 取出字母d
字符串切片语法:
[起始索引:结束索引:步长]
- 注意:切片的时候是
左闭右开型
,即包含开始不包括结束print(a[0:2]) # 取出He
print(a[0:4]) # 取出Hell
print(a[-2:]) # 取出ld
print(a[:]) # 从头取到尾
print(a[::2]) # 从头取到尾,每隔2个取一个
4. 转义字符
转义字符:是指使用反斜杠\
对一些特殊字符进行转义
常见的转义字符如下:
\n 换行符
\t 水平制表符(对齐)
让转义字符不转义的方法:
- 在
\
后再加一根\
:print('D:\\n\\t')
- 在整个字符串前加
r
:print(r'D:\n\t')
python路径中的正反斜线是等价的,举例:
C:\\test # 用两个斜线,避免被转义
C:/test # 用一个即可
5. 字符串的格式化
-
5.1 百分号格式化
先用下面的占位符占好位置,然后再将值传入
%s
:字符串%d
:整数%f
:浮点数,通过%.nf
指定精度,n是数字,保留几位就写几 ```python name = ‘小方’ age = 18 money = 100.1
print(‘他叫%s,他今年%d岁,他身上有%.1f元钱’ %(name, age, money))
> 注意:如果需要填充多个值,值需要用括号括起来
<a name="17b79d89"></a>
### 5.2 使用format函数
使用`format`进行格式化,统一用`{}`占位,不用考虑数据类型
```python
print('他叫{},他今年{}岁,他身上有{}元钱'.format(name, age, money))
# 指定精度 {:.nf}
print('他叫{},他今年{}岁,他身上有{:.1f}元钱'.format(name, age, money))
# 可以通过编号的方式,重复填入数据,注意编号从0开始
print("他叫{0},他今年{1}岁,我也是{1}岁,他身上有{2}元钱".format(name, age, money))
5.3 f{string}
- 498新特性,直接在字符串前加f,大括号中直接指定变量,可以直接填充
文档说明:https://www.python.org/dev/peps/pep-0498/
# 方法三
print(f"您输入的用户是:{username},密码是:{password}")
# 如果需要保留小数,可以使用如下方法:
num = 109.126
print(f"zifuchuan:{num:0>.2f}")
6. 字符串的常用方法
替换字符串中的字符:
str.replace(旧字符,新字符)
- 分割字符串:
str.split(分割标志)
,返回列表 - 查找指定字符:
str.find(字符)
,返回字符第一次出现的索引值,没有则返回-1 ```python a = ‘tashi’ a = a.replace(‘t’, ‘T’) # 替换字符串
b = ‘a, b, c, d’ result = b.split(‘,’) # 分割字符串 print(result)
print(a.find(‘G’)) # 查找指定字符,返回第一次出现的索引值,没有则返回-1
<a name="75d1c505"></a>
## 7. 输入字符串
- 从键盘输入字符使用`input(输入提示)`函数,并保存到指定的变量中。
- `input`接收的所有数据都保存成字符串类型
```python
print('欢迎来到它石科技管理系统~')
username = input('请输入您的用户名:')
password = int(input('请输入您的密码:')) # 可以加类型转换
print('您输入的用户名是:{},密码是:{}'.format(username, password))
第九章 列表(List)
1. 定义
- 列表是「Python」中的一种基础数据结构,由
[]
包围 - 列表中每个数据就是一个元素,元素之间以 逗号 隔开
-
2. 特点
有序:有索引
- 可变:可以修改自身
3. 快速生成数字列表
list(range(开始值,结束值,步长))
注意:
range
同样包含开始但是不包含结束
a = list(range(1, 101)) # 生成一个包含1-100之间的所有数字的列表
b = list(range(2, 101, 2)) # 快速生成1-100之间的所有偶数的列表
4. 列表的嵌套取值
列表中的元素也可以是列表,叫做 列表嵌套
列表嵌套取值就是将取出的列表继续取值即可
food = [['湖南', '槟榔'], ['福建', '沙县小吃', ['10块钱一份','好吃不贵']], ['湖北', '热干面']]
print(food[0][1]) # 取出槟榔
print(food[1][2][0]) # 取出十块钱一份
5. 列表的常见方法
- 增加
- 追加元素到列表最后:
list.append(值)
- 在指定索引位置插入值:
list.insert(索引,值)
- 追加元素到列表最后:
- 删除
- 删除指定索引位置的值:
list.pop(索引)
,不填索引,则删除最后一个 - 根据值删除元素:
list.remove(值)
,如果有多个值,则删除第一个
- 删除指定索引位置的值:
- 修改
- 先取值,再重新赋值:
list[索引] = 新值
- 先取值,再重新赋值:
- 反转:
list.reverse()
- 统计
- 最大值:
max(list)
- 最小值:
min(list)
- 长度:
len(list)
- 最大值:
排序
元组是「Python」中的一种基础数据结构,用
()
包围- 元组中的每个数据叫元素,元素之间用逗号隔开
- 元素可以是任意的数据类型
注意:当元组中有且只有一个元素时,必须要用逗号结尾,否则就不是元组
2. 特点
有序
- 不可变
3. 列表与元组互转
如需修改元组,可将元组转成列表,进行修改,改完再转回即可a = (1, 2, 3)
a = list(a) # 将元组转成列表
a.append(4) # 在列表中追加4
a = tuple(a) # 将列表转成元组
print(a)
4. 元组常用方法
统计
- 最大值:
max(tuple)
- 最小值:
min(tuple)
- 长度:
len(tuple)
第十一章 字典(Dict)
1. 定义
- 字典是「Python」中的一种基础数据结构,用
{}
包围 - 字典中的元素以
键值对
的形式存在, -
2. 特点
无序
-
3. 字典的常用方法
根据键修改值:
dict[键] = 值
- 根据键删除键值对:
dict.pop(键)
- 字典取值时,如果键值对不存在,则自动添加:
dict[键] = 值
- 获取所有键:
dict.keys()
- 获取所有值:
dict.values()
- 获取所有键值对:
dict.items()
第十二章 选择语句
1. 格式
if 条件:
条件满足时做的事情1
条件满足时做的事情2
... ...
else:
条件不满足时做的事情1
条件不满足时做的事情2
... ...
练习:询问用户年龄,只有18岁及以上者才能进入酒吧
age = int(input('请输入您的年龄:')) # 用户输入年龄
if age>=18: # 判断用户的年龄是否大于等于18岁
print('欢迎光临')
else:
print('禁止未成年人进入!')
2. elif
判断多个条件
score = float(input('请输入您的成绩:'))
if 0<=score<60:
print('您的成绩不合格')
elif score>=60 and score<70:
print('您的成绩一般')
elif 70<=score<80:
print('您的成绩是中等')
elif 80<=score<90:
print('您的成绩良好')
elif 90<=score<=100:
print('您的成绩优秀!')
else:
print('您的输入有误,请重新输入!')
month = int(input('请输入月份:'))
if 3<=month<=5:
print('春季')
elif 6<=month<=8:
print('夏季')
elif 9<=month<=11:
print('秋季')
elif month==12 or 1<=month<=2:
print('冬季')
else:
print('您的输入有误,请重新输入!')
# ----------------计算器-------------
# 编写一个小程序:对任意两数进行加减乘除运算
num1 = int(input("请输入第一个数字:"))
num2 = int(input("请输入第二个数字:"))
flag = input("请输入需要进行的运算(+、-、*、/):")
if flag == '+':
print(f'{num1}+{num2}={num1 + num2}')
elif flag == '-':
print(f'{num1}-{num2}={num1 - num2}')
elif flag == '*':
print(f'{num1}*{num2}={num1 * num2}')
elif flag == '/':
print(f'{num1}/{num2}={num1 / num2}')
else:
print("您的输入有误!")
# BMI计算器
# ============BMI计算器================
# BMI计算公式:体重(kg) / 身高(m)**2
print("欢迎使用它石牌BMI计算器~")
weight = float(input("请输入您的体重(kg):"))
height = float(input("请输入您的身高(m):"))
bmi = round(weight / (height ** 2), 1)
print(bmi)
if bmi <= 18.4:
print("您的体型偏瘦,请多吃点~")
elif 18.5 <= bmi <= 23.9:
print("您的体型正常,请继续保持~")
elif (bmi >= 24.0) and (bmi <= 27.9):
print("您的体型过重,请多运动~")
elif bmi >= 28.0:
print("您的体型肥胖,请绝食~")
else:
print("您的输入有误~")
3. if 嵌套
在一个if
中嵌入另外一个if
age = int(input('请输入您的年龄:')) # 用户输入年龄
beer = True # 1表示带了酒水,0表示没有带
if age>=18: # 判断用户的年龄是否大于等于18岁,只有年龄符合要求才有过安检的机会
print('请过安检~')
if beer==True:
print('您不能进入,因为您带了酒水')
else:
print('欢迎光临')
else:
print('禁止未成年人进入!')
4. if应用:猜拳游戏
import random # 导入随机数包
player = int(input('请输入石头(0)剪刀(1)布(2):')) # 玩家出一个数字
computer = random.randint(0, 2) # 电脑随出一个0-2之间的随机整数
print('玩家出的是:{},电脑出的是:{}'.format(player, computer))
# 所有玩家会赢的场景
if (player==0 and computer==1) or (player==1 and computer==2) or (player==2 and computer==0):
print('恭喜你赢了,真棒~')
elif player==computer: # 玩家与电脑平局的场景
print('平局了哦,要不要再来一局~')
else: # 剩下的就是玩家输的场景
print('很遗憾,你输了,再接再厉~')
第十三章 循环语句
1. 程序的三大执行方式
2. while循环
2.1 格式
while 条件:
条件满足时重复做的事情
2.2 打印1-100之间的数字
num = 1
while num<=100:
print(num)
num += 1
2.3 打印矩形
num = 1
while num<=9:
print('*'*9)
num += 1
2.4 双层循环打印矩形
i = 1
while i<=9: # 外循环控制行数
j = 1
while j<=9:
print('*', end='') # 内循环控制每行个数,end=‘’让print不换行
j += 1
print('') # 内循环执行完成后,主动换行
i += 1
2.4 双层循环打印三角形
i = 1
while i<=9: # 外循环控制行数
j = 1
while j<=i:
print('*', end='') # 内循环控制每行个数,end=‘’让print不换行
j += 1
print('') # 内循环执行完成后,主动换行
i += 1
2.5 双层循环打印九九乘法表
i = 1
while i<=9:
j = 1
while j<=i:
print('{}*{}={}'.format(j,i,j*i), end='\t')
j += 1
print('')
i += 1
2.6 面试题:数7游戏
# --------------------数7游戏-----------
# 打印1-20之间不是7的倍数以及数字中不包含7的数字
i = 1
while i<=20:
# if i%7!=0 and str(i).find('7')==-1:
if i%7!=0 and i%10!=7:
print(i)
i += 1
2.7 while习题
# 模拟一个登录系统,当用户名为admin, 密码为123时即登录成功,否则登录失败
# 只有三次登录机会
print("欢迎使用管理系统~")
i = 1
while i <= 3:
username = input("请输入您的用户名:")
password = input("请输入您的密码:")
if username == "admin" and password == "123":
print("登录成功")
break # 如果登录成功,则跳出剩下所有循环
else:
print("登录失败")
i += 1
3. for循环
3.1 格式
for 临时变量 in 序列:
循环体
3.2 作用
- 一般用来 遍历 序列
- 循环次数与序列长度对应 ```python for i in ‘abc’: # 遍历字符串 print(i)
for i in [1,2,3]: # 编列列表 print(i)
student = {‘name’:’zs’, ‘age’:18, ‘sex’:’boy’} print(student.items()) for i in student.keys(): print(i) for i in student.values(): print(i) for i,j in student.items(): # 遍历字典中键值对 print(‘{}={}’.format(i,j))
<a name="7c47bb21"></a>
### 3.3 打印1-100之间的数字
```python
for i in range(1, 101): # 打印1-100之间的数字
print(i)
3.4 打印矩形
for i in range(1, 10): # 打印9*9的矩形
print('*'*9)
3.5 打印三角形
for i in range(1, 10):
for j in range(1, i+1):
print('*', end='')
print('')
3.6 打印九九乘法表
for i in range(1, 10):
for j in range(1, i + 1):
print(f'{j}*{i}={j * i}', end='\t')
print()
3.7 for与if嵌套使用
names = ['zs', 'ls', 'ww']
for i in names:
if i=='zs':
print('恭喜你中奖了~')
else:
print('不好意思,没有中奖')
3.8 习题
# ----------------练习题1: 获取任意字符串的长度(不能使用len())------------------
a = input('xxx')
num = 0
for i in a:
num += 1
print(num)
# ----------------练习题2: 求1-100之间所有能被3整除且不能被4整除的数------------------
nums = []
for i in range(1,101):
if i%3==0 and i%4!=0:
nums.append(i)
print(nums)
# ---------------练习题3:统计任意字符串中的数字与字母个数,分别打印--------------------
a = input('请输入需要统计的字符串:')
num = 0
letter = 0
for i in a:
if i in '1234567890':
num += 1
elif i in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ':
letter += 1
print('该字符串中数字的个数是{},字母的个数是:{}'.format(num, letter))
# isdigit 数字 isalpha 字母
# ---------------练习题4:求1-100之间所有偶数和--------------------------
a = 0
for i in range(2, 101, 2):
a += i
print(a)
for i in range(1, 101):
if i%2==0:
a += i
# -----------------练习题5:兔子数列,假设有1对兔子,2个月成年,成年后可以生一对兔子,假设所有兔子
# -------------------------不会死的情况下,第12个月会有多少对兔子?-----------------------
# ----------------斐波那契数列:从1开始,后面的数是前面两数之和-----------------
# 1 1 2 3 5
a, b = 0, 1
nums = []
for i in range(1, 13):
nums.append(b)
a, b = b, a+b
print(nums)
4. 冒泡排序
# ---------------------冒泡排序--------------------
# 从小往大
nums = [10, 3, 4, 1]
for i in range(len(nums)-1): # 控制比较次数
for j in range(len(nums)-1-i): # 控制每次用来比较数字的索引值
if nums[j]>nums[j+1]: # 如果第一个数字比第二个数字大
nums[j],nums[j+1] = nums[j+1], nums[j] # 则交换位置
print(nums)
5. 跳出循环
- break:跳出剩下的整个循环
-
第十四章 函数
1. 函数的定义
函数就是将具有相同功能的代码块 封装 成一个小模块
- 封装好以后不仅可以 无限次 使用并且可以在 不同 地方使用
- 通过
函数名()
的方式可以调用函数注意:函数在定义好以后不会自动运行
2. 格式
def 函数名():
代码块
3. 文档注释
- 函数的文档注释用
一对三单引号/双引号
包围,用来解释说明函数的作用 -
4. 函数的参数
形式参数:函数定义时的参数
- 实际参数:调用函数时传入的参数 ```python def addtion(a, b): # a,b是形式参数 c = a + b print(c)
addtion(2, 2) # 2,2是实际参数
<a name="71d6def8"></a>
## 5. 函数参数的传递方式
- **位置传递**:形参与实参按照位置关系一一对应
- **关键字传递**:在调用函数时,通过实参指定形参的值,不受位置关系影响(可以乱序)
- **参数的默认值**:函数的形参可以有默认值,如果形参有默认值并且调用时没有传入实参,则使用默认值,如果传入了实参,则使用传入值,没有默认值的形参必须要放到有默认值的形参前面
```python
# -------------------关键字传递----------------------
def addtion(a, b): # a,b是形式参数
c = a - b
print(c)
addtion(b=2, a=3) # 指定形参的值,不受位置关系影响
# -------------------参数的默认值--------------------
def addtion(b, a=3): # a,b是形式参数
c = a - b
print(c)
addtion(2) # 如果形参有默认值,则调用时可以不传入实参,不传则使用默认值
6. 函数的返回值
- 函数执行后一般情况下都会产生执行结果,使用
return
将执行结果返回给调用者,这就是返回值 - 如果函数中没有定义
return
,则函数的返回值为None
函数一旦执行到
return
,就不会继续往下执行def addtion(a,b): return a+b # 使用return将执行结果返回给调用者
7. 局部变量与全局变量
局部变量:定义在函数内部的变量,只在函数内部生效
- 全局变量:定义在函数外部的变量,整个代码文件都生效
- 使用
global
可以将局部变量声明成全局变量num = 10 # 全局变量 def addtion(): global a # 使用global可以将局部变量声明成全局变量 a = 10 # 局部变量 print(num)
第十五章 异常处理
1. 捕获异常
当代码中出现异常时,程序会抛出异常并且停止运行,如果希望代码在出现异常后,继续往下执行
,则需要捕获异常
捕获异常的格式:
try:
可能会出现异常的代码
except Exception as e:
出现异常后执行的代码
else:
没有异常时执行的代码
finally:
不管有没有异常都会执行的代码
注意:
else
与finally
为非必写
print('程序开始执行...')
try:
print(a) # a没有定义,会报错
except Exception as e:
print('程序出现了异常,异常是:{}'.format(e))
# else:
# print('恭喜你,没有任何异常!')
# finally:
# print('我一定会执行')
print('程序执行结束...')
2. 抛出异常
当希望代码在指定情况下出现异常
,则需要抛出异常
抛出异常的格式为:raise Exception(错误提示)
# 希望用户输入一个大于100的整数
# 如果用户输入有误,则抛出异常
print("程序开始了")
num = int(input("请输入一个大于100的整数:"))
if num > 100:
print("输入成功")
else:
try:
raise Exception("输入有误!")
except Exception as e:
print("程序出现了异常,异常信息是:{}".format(e))
print("程序结束了")
第十六章 文件操作
1. 打开文件
打开文件使用open(file,mode)
函数,该函数参数定义如下:
file
:文件名,可以是包含路径的文件名mode
:文件打开模式读取所有内容:
read()
- 读取前n个字符:
read(n)
,多次使用会从上次读取位置继续往后读取 - 读取一行:
readline()
,多次使用会从上次读取位置继续往后读取 - 按行读取所有内容:
readlines()
,返回列表5. 中文处理
在文件中写入 中文 时可能会出现 乱码 现象,这时指定文件的编码格式为utf-8
,即可解决该问题# 中文乱码时,加上encoding指定编码方式,为utf-8 file = open('tashi.txt', 'w', encoding='utf-8') file.write('中国很强!') file.close()
6. 文件的自动打开与关闭
使用with open
结构打开文件,在文件操作结束后可以自动关闭文件with open('tashi.txt', 'r', encoding='utf-8') as f: result = f.read() print(result) print(f.closed) # 使用closed验证文件是否已经关闭
7. 应用:备份文件
```python old_file = input(‘请输入需要备份的文件:’)
suo_yin = old_file.find(‘.’) hou_zhui = old_file[suo_yin:] # 取出文件后缀 qian_zhui = old_file[:suo_yin] # 取出.前面的部分 new_file_name = qian_zhui + ‘-副本’ + hou_zhui # 拼接新文件名 file = open(old_file, ‘r’, encoding=’utf-8’) # 读取原文件内容 result = file.read() file2 = open(new_file_name, ‘w’, encoding=’utf-8’) # 将读取内容写入新文件 file2.write(result)
file.close() # 关闭文件 file2.close()
<a name="f87a1b4c"></a>
# 第十七章 模块
<a name="5d7b406e"></a>
## 1. 导入模块的方法
- `import 模块名`
- `from 模块名 import 函数`
<a name="2f42eb74"></a>
## 2. 安装模块
<a name="759136c8"></a>
### 2.1 自动安装
- 在命令行中输入:`pip install 模块名`,默认安装最新版本
- 安装指定版本:`pip install 模块名==2.1`
- 验证是否安装成功:`pip list`,(查看所有已安装模块及版本号)
<a name="98599a38"></a>
### 2.2 手动安装
- 进入[https://pypi.org](https://pypi.org),搜索下载需要安装的包
- 将下载好的包解压
- 进入解压目录,在顶部地址栏中输入`cmd`(在当前位置打开命令行)
- 在打开的命令行中输入:`python setup.py install`(手动执行本地安装)
<a name="c0e9f855"></a>
## 3. 常用模块
**time(时间)**
```python
import time
# 获取当前时间
print(time.ctime())
# 获取当前时间,并且按照指定格式保存 2019-10-29 14:52:01
print(time.strftime('%Y/%m/%d %H:%M:%S'))
# 休眠
time.sleep(2)
print(time.strftime('%Y/%m/%d %H:%M:%S'))
OS(系统)
import os
# 获取当前文件所在路径
print(os.getcwd())
# 获取当前文件所在目录的上级目录
print(os.path.dirname(os.path.dirname(__file__)))
os.mkdir('linux') # 新建目录
os.rmdir('linux') # 删除目录
os.remove('tashi-副本.txt') # 删除文件
删除非空目录:
import shutil
shutil.rmtree('c:\\test')
json
# --------------------读取json--------------------------
import json
result = json.loads('{"name":"zs", "age":18}') # 将字符串类型json数据转为字典
print(type(result))
# --------------------生成json--------------------------
dict_data = {"name":"zs", "age":18} # 将字典转换成字符串类型的json数据
json_data = json.dumps(dict_data)
print(type(json_data))
注意:字典中包含中文,转为json时中文乱码, 传入ensure_ascii=False参数即可解决
第十八章 面向对象
1. 面向对象与面向过程
- 面向过程:根据业务流程从上往下写代码,所有步骤都参与(吃烤鸭:买鸭蛋—>养鸭子… …)
面向对象:将数据与函数绑定在一起,定义成类,通过类可以生成无数个对象,提高开发效率(吃烤鸭:直接买)
2. 类和对象
类
是泛指一类事物(狗,猫,人… …)-
3. 类的组成部分
类名(dog)
- 属性(狗有2只眼睛,4条腿… … )
- 方法(狗能吃,跑,叫… …)
4. 定义类
定义一个 狗类
根据类创建对象 ```python wangcai = Dog() # 类的实例化,就是创建对象 wangcai.eat() # 对象调用类中的方法 wangcai.chai_jia()class Dog(): # 类名用大驼峰 # 属性 # 方法 def eat(self): print('狗正在吃东西') def chai_jia(self): print('狗正在拆家')
dahuang = Dog() dahuang.eat()
<a name="9044f9f5"></a>
## 5. 类的初始化
在类中使用`__init__`方法进行自动化,并将类属性定义在该方法中<br />类属性与`self`绑定,这样就可以在其他方法中使用该属性
```python
class Dog(): # 类名用大驼峰
# 属性
def __init__(self): # 在初始化方法中定义属性值,初始化一定会自动运行
self.color = '黄色' # 通过self绑定属性,这样就可以在其他方法中使用该属性
self.food = '骨头'
print('初始化开始~')
6. 继承
如果一个类是一个大类中的一小类,那么这个类可以继承这个大类
被继承的类叫 父类,继承的类的叫 子类
子类继承父类以后有如下特点:
- 子类可以使用父类中的 所有 方法
- 子类可以新增父类中 没有 的方法
子类可以 修改 父类中的方法
class XiaoTianQuan(Dog): # 哮天犬继承狗类 def eat(self): print('哮天犬正在吃仙丹') # 在子类中定义一个与父类同名的方法,达到修改方法的效果 def fly(self): # 哮天犬新增自己独有的方法 print('哮天犬正在飞~') XTQ = XiaoTianQuan() # 实例化,生成一只哮天犬 XTQ.eat() # 使用父类中的方法 XTQ.chai_jia() XTQ.fly()
7. 最终
```python
定义一个狗类
class Dog(): # 类名用大驼峰
# 属性
def __init__(self, color, food): # 在初始化方法中定义属性值,初始化一定会自动运行
self.color = color # 通过self绑定属性,这样就可以在其他方法中使用该属性
self.food = food
# print('初始化开始~')
# 方法
def eat(self):
print('{}的狗正在吃{}'.format(self.color, self.food))
def chai_jia(self):
print('{}的狗正在拆家'.format(self.color))
wangcai = Dog(‘金色’, ‘剩饭’) # 类的实例化,就是创建对象 wangcai.eat() # 对象调用类中的方法 wangcai.chai_jia()
hashiqi = Dog(‘黑白相间’, ‘狗粮’) hashiqi.eat()
继承
class XiaoTianQuan(Dog): # 哮天犬继承狗类 def eat(self): print(‘哮天犬正在吃仙丹’) # 在子类中定义一个与父类同名的方法,达到修改方法的效果
def fly(self): # 哮天犬新增自己独有的方法
print('哮天犬正在飞~')
XTQ = XiaoTianQuan(‘红色’, ‘仙丹’) # 实例化,生成一只哮天犬 XTQ.eat() # 使用父类中的方法
XTQ.chai_jia()
XTQ.fly()
<a name="34426d78"></a>
# 第十九章 习题
<a name="2efd0f0e"></a>
## 1. 数7游戏
```python
# -----------------------数7游戏-------------------------
# 7的倍数以及包含7的数字都不能说,只能拍手
i = 1
nums = []
while i<=100:
if i%7!=0 and str(i).find('7')==-1:
nums.append(i)
i += 1
print(nums)
2. BMI计算器
# --------------------BMI计算器----------------------
print('欢迎来到它石BMI计算器~')
weight = float(input('请输入您的体重(kg):'))
hight = float(input('请输入您的身高(m):'))
bmi = float(format(weight/hight**2, '.1f'))
print(type(bmi))
print('请稍后,正在计算中~')
print('您的BMI指数为:{}'.format(bmi))
if bmi<=18.4:
print('您的体型偏瘦,多吃点~')
elif 18.5<=bmi<=23.9:
print('您的体型正常,继续保持~')
elif 24.0<=bmi<=27.9:
print('您的体型过重,少吃点~')
elif bmi>=28.0:
print('您的体型肥胖,请辟谷~')
else:
print('您的输入有误,请重新输入~')
3. 输入数字并排序
# -----------用户输入三个数字,将这三个数字按照从小到大顺序排列并输出------------------
nums = []
for i in range(3):
num = int(input('请输入一个整数:'))
nums.append(num)
nums.sort()
print(nums)
4. 批量生成SQL
# -----------------练习题7:批量生成SQL--------------------
# inert into student value(tashi00001);, 从1-10000,写入tashi.txt中
with open('tashi.txt', 'w') as f:
for i in range(1, 10001):
f.write('insert into student value(tashi{:0>5d});\n'.format(i))
5. 字典中的键值颠倒
现有sport = {'cn':'pingpang', 'us':'basketball', 'africa':'football'}
,请将该字典中的键值颠倒并产生新的字典
sport = {'cn':'pingpang', 'us':'basketball', 'africa':'football'}
# sport = {y:x for x,y in sport.items()}
# print(sport)
new_sport = {}
for k,v in sport.items():
new_sport[v] = k
print(new_sport)
6.闰年判断
输入任意年份,判断该年份是否为闰年
year = int(input('请输入需要查询的年份:'))
if (year%4==0 and year%100!=0) or year%400==0:
print('{}年是闰年'.format(year))
else:
print('{}年不是闰年'.format(year))
7. 输入多个数字,判断大小
用户输入任意5
个数字,请将这个5
个数字中最大数字找出来并打印
nums = []
for i in range(1,6):
num = int(input("请输入第{}个数字:".format(i)))
nums.append(num)
print('您输入的数字中,最大数字为{}'.format(max(nums)))
8. 简单计算器
编写一个小程序:实现简单的加减乘除功能
print('请选择您需要的运算:')
print('1.加法运算')
print('2.减法运算')
print('3.乘法运算')
print('4.除法运算')
choice= int(input('请输入您的选择:1(加法)/2(减法)/3(乘法)/4(除法):'))
num1 = int(input('请输入第一个数字:'))
num2 = int(input('请输入第二个数字:'))
if choice==1:
print('{} + {} = {}'.format(num1, num2, jia(num1, num2)))
elif choice==2:
print('{} - {} = {}'.format(num1, num2, jian(num1, num2)))
elif choice==3:
print('{} * {} = {}'.format(num1, num2, cheng(num1, num2)))
elif choice==4:
print('{} / {} = {}'.format(num1, num2, chu(num1, num2)))
else:
print('您的输入有误!')
9. 统计字符出现的个数
统计任意字符串中每个字符出现的次数
def count(str):
result = {}
for i in str:
if i in result:
result[i]+=1
else:
result[i]=1
return result
print(count('abc'))
10. 求100以内的所有质数
# python求100以内的质数
# 质数定义是大于1的自然数中,除了1和它本身外不再有其他因数
nums = []
for i in range(2, 101):
for j in range(2, i):
if i%j==0: # 如果条件满足,直接跳出for,不执行else
break
else: # 如果条件不满足,则添加这个数到列表中
nums.append(i)
print(nums)
# [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
11. 判断回文字符串
回文字符串就是不管从左往右还是从右往左看,值都是一样的
# a = 'abcba'
a = input("请输入需要判断的字符串:")
b = reversed(list(a)) # 将字符串转成列表后再反转一下
if list(a) == list(b): # 如果输入的字符串转成列表后和反转过后的列表的值一样,那么就是回文字符串
print('是回文')
else:
print('不是回文')
12. 统计列表中字符串出现的次数
现有 a = [“apple”, “banana”, “apple”],统计其中每个单词出现的次数
a = ["apple", "banana", "apple", "apple", "banana"]
res = {}
for i in a:
res[i] = res.get(i, 0) + 1
print(res)
# {'apple': 3, 'banana': 2}
13. 合并两个列表为字典
现有 a = [“a”, “b”, “c”], b = [1, 2, 3],将a,b合并为字典。a中的元素作为字典中的键,b中的元素作为字典中的值。
a = ["a", "b", "c"]
b = [1, 2, 3]
res = dict(zip(a, b))
print(res)
14. 列表推导式
现有 a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],使用列表推导式求出所有奇数并构造新列表
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
res = [i for i in a if i%2!=0]
print(res)
15. 列表元素长度排序
现有 a = [“ab”, “a”, “a12”, “xmkj12”],将该数据按照每个字符串长度排序
# 方法一
a = ["ab", "a", "a12", "xmkj12"]
a.sort(key=lambda x:len(x))
print(a)
# ['a', 'ab', 'a12', 'xmkj12']
# 方法二
a = ["ab", "a", "a12", "xmkj12"]
for i in range(len(a)):
for j in range(len(a) - 1):
if len(a[j])>len(a[j+1]):
a[j], a[j+1] = a[j+1], a[j]
print(a)