python

Python简介

第一章 简介

1.起源

Python是由吉多-范罗苏姆在1989年圣诞节发明的一个解释程序

Python的中文释义：蟒蛇

Python是一门解释型语言，运行前无需编译

Python的版本

Python2：最初发布于2001年，是过去的版本，于2020年停止维护

Python3：最初发布于2008年，我们学习的版本

格言： Life is short, you need Python! （人生苦短，我用Python~）

2.应用

自动化测试：编写自动化脚本

Web开发：豆瓣、知乎、YouTube

人工智能：语音助手、智能音箱

云计算：云服务器

第二章 安装 python

2.1 python

2.2 验证

在命令行中输入： python

如果能够看到版本号以及进入交互模式，即表示安装成功

第一个Python程序

首先进入交互模式

输入第一行代码： print(“HelloWorld”) ，在屏幕上输出 HelloWorld

2.3 下载地址

官网：https://www.python.org/download

第三章 安装 pycharm

3.1 下载地址

官网：https://www.jetbrains.com/pycharm

3.2 安装

默认安装即可

3.3 创建项目

3.4 基本布局

3.5 设置字体

3.6 设置主题

3.7 设置运行代码快捷键

第四章 注释

4.1定义

注释是用来解释说明代码的作用的

注释本身是不会被运行的

4.2注释方法

单行注释用 # 表示

只在一行生效，可以写在代码后面，也可以单独写一行

多行注释

用一对 三单引号/三双引号 表示

多行注释可以换行，多行注释有特殊用途（文档注释）

注释快捷键

选中代码，按 ctrl + / ，即可快速注释

若要取消注释，再按一次 ctrl + / 即可

第五章 基础数据5类型

# type()可以查看数据的类型 
# str 字符串
print(type("abc")) 
print(type('')) # 空字符串 
print(type("i'm ok")) # 外双里单 

# int 整数 
print(type(2)) 
print(type(-2)) 
print(type(0)) 

# float 浮点数 
print(type(0.0)) 
print(type(-3.0)) 

# bool 布尔值 
print(type(True)) 
print(type(False)) 

# Nonetype 空 
print(type(None))

第六章 变量

6.1 定义

变量是一个容器，可以用来存储任意类型的数据

变量实质上是储存在内存中的一个值

变量定义好以后可以通过变量名称无限次的调用

6.2 变量命名规范

只能包含数字、字母以及下划线

不能用数字开头

不能使用系统关键字

区分大小写

# 只能包含数字、字母、下划线

student_1 = “zs”

print(student_1)

# 不能使用系统关键字

# True = 2 # ×

true = 2

print(true)

import keyword # 导入关键字模块

print(keyword.kwlist) # 查看关键字列表

# 区分大小写

a = 1

A = 2

print(A)

6.2.1 推荐命名方式

驼峰命名法：

大驼峰：每个单词的首字母大写，如 FirstLove

小驼峰：从第二个单词开始，首字母大写，如 firstLove

使用下划线拼接，如 first_love

6.3 赋值3方式

普通赋值：将右边的数据赋给左边的变量

序列解包赋值：在一行代码中，同时给多个变量赋不同的值，按照位置关系一一对应

链式赋值：在一行代码中，同时给多个变量赋同一个值

num = 1 # 普通赋值 

num1, num2 = 10, 9 # 序列解包赋值 

print(num1, num2) 

a = b = c = 99 # 链式赋值 

print(a, b, c) 

第七章 运算符

7.1 基础运算符

运算符	描述
+	加法，除了计算整数和，还可以拼接字符串
-	计算两数之差
*	计算两数的乘积，还可以复制字符串
/	计算两数之商，整数相除，结果必为浮点数，使用int（）可以进行 类型转换
//	取整
%	取余
**	幂运算

print(1 + 2) 
print(1 - 2) 
print(1 * 2) 
print(8 / 2) # 整数相除，结果必为浮点数 
print(int(8 / 2)) # 类型转换 
print("a" + "99") # 加法还可以拼接字符串 
print("tashi" * 10) # 复制字符串 
# 取整除 
print(10 // 3) 
# 取余数 
print(10 % 3) 
# 幂运算 
print(2 ** 4)

7.2 复合赋值

num = 1 
print(num) 
num += 1 # num = num + 1 
print(num) 
num *= 2 # num = num * 2 
print(num) 
num /= 2 # num = num / 2 
print(num)

7.3 逻辑运算符

and：和，并且

or：或者

not：非

print(True and True) # 两边为真，结果就为真 
print(True and False) # 一边为假，结果就为假 
print(False or True) # 一边为真，结果就为真 
print(not True) # 非真即假 
print(not False) # 非假即真 
print(3 > 2 and 3 < 2)

7.4 比较运算符

运算符	描述
>	大于
<	小于
>=	大于等于
<=	小于等于
!=	不等于
==	等等于

print(3 > 2) # True 
print(3 < 2) # False 
print(3 >= 3) # True 
print(3 <= 2) # False 
print(3 == 2) # False 判断两边是否相等 
print(3 != 3) # False 判断两边是否不相等

7.5优先级

先算小括号内，再算小括号外

第八章 字符串

字符串是由一对 单引号/双引号/三单引号/三双引号 包围

特点:

• 有序：有索引值
• 不可变：不能直接修改自身

8.1 索引值与取值

8.2 取单个值

string = "HelloWorld" 
# 取值
# 语法：字符串[索引值] 
print(string[5]) # 取出W 
print(string[-5]) # 取出W 
print(string[-1]) # 取出d 
print(string[0]) # 取出H

8.3 切片

语法： `数据/变量名[起始索引值:结束索引值:步长]

注意：只包含开始不包含结束

步长表示每隔几个取一个，步长为负数时，反过来取

# 切片 
# 语法：字符串[起始索引值：结束索引值：步长] 
# 只包含开始不包含结束 
print(string[0:2]) # 取出He 
print(string[4:7]) # 取出第5-7个字符 
print(string[-2:]) # 取出ld 
print(string[8:]) # 取出ld 
print(string[:]) # 从头取到尾 
print(string[::2]) # 从头取到尾，每隔2个取1个 
print(string[::3]) # 从头取到尾，每隔3个取1个 
print(string[::-1]) # 反转字符串 
print(string[::-5]) # 从右往左取，每隔5个取1个

8.4****转义字符

定义：用 \ 加上一些字符来表示特殊键位 
常见的转义字符： 
换行： \n 
制表符(补齐键)： \t ，tab

如何使转义字符不转义： 
方法一：在每个转义字符的斜线后面再加一根斜线 
方法二：直接在整个字符串前加个r

print("tashi\ntashi") # 换行符 
print("tashi\ttashi") # 制表符（缩进） 
print("tashi\ttashi") 
print("D:\\n\\t\\test.txt") # 方法一 
print(r"D:\n\t\test.txt") # 方法二

8.5 输入字符串

输入字符串使用： input（输入提示）

注意：在Python3中，所有输入的数据都会被保存成字符串类型，如果需要保存成其他类型，需要进行类型转换

print("欢迎使用它石管理系统~") 
username = input("请输入您的用户名：") 
password = input("请输入您的密码：") 
age = int(input("请输入您的年龄：")) 
money = float(input("请输入您的余额：")) 
print(username) 
print(type(username)) 
print(type(age)) 
print(type(money))

8.6 格式化

字符串的格式化是指将字符串按照一定的格式打印或者填充

字符串的格式化方法有如下两种

方法一：使用百分号格式化 
先用下面的占位符占好位置，再将值传入： 
%s ：字符串 
%d ：整数 
%f ：浮点数，若要指定精度，则为 %.nf ， n 是一个整数，保留几位就写数字几 

print("欢迎使用它石管理系统~") 
username = input("请输入您的用户名：") 
password = input("请输入您的密码：") 
age = int(input("请输入您的年龄：")) 
money = float(input("请输入您的余额："))

# int %d float %.nf string %s 
print("您输入的用户名是：%s，密码是：%s，年龄是：%d，余额是：%.2f元。" %(username, password, age, money))

方法二：使用format函数格式化 
统一使用 {} 占位，无需考虑数据的类型 

print("您输入的用户名是：{}，密码是：{}，年龄是：{}，余额是：{} 元。".format(username, password, age, money))

8.7 字符串常用3方法

替换： replace(旧值，新值)

查找： find(关键字) ，返回第一个找到的字符的索引值，找不到返回 -1

切割： split（切割标志） ，返回列表

string = "china" 
print(id(string)) 
string = string.replace("c", "C") # 将c替换成C 
print(id(string)) 
print(string) 
result = "code:200, msg:login success, msg" 
print(result.find("msg")) # 在字符串中查找指定字符，返回首字母索引 
a = "a|b|c|d" 
print(a.split("c")) # 切割字符串，返回列表！！！ 
ip = "IPv4 地址 . . . . . . . . . . . . : 192.168.52.57" 
print(ip.split(": "))

## 不需要记忆,,有个印象 
a = ' abCd abcd ' 
b = a.upper() # 转成大写 
c = a.count('ab') # 统计ab 出现的次数 
d = a.rstrip() # 去掉右边的空格 
e = a.lstrip() # 去掉左边的空格 
f = a.strip() # 去掉两边的空格 
= a.swapcase() # 大小写互换!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
h = a.lower() # 全部变小写 
i = a.title() # 每个单词首字母大写,其他字母小写

第九章 列表（list）

9.1 定义

列表是Python中的一种基础数据结构，由 [] 包围

列表中可以存放任意类型的数据，每个数据被称作一个元素，元素间用逗号隔开

# 定义一个数字列表 
nums = [1, 2, 3] 
print(nums) 
print(type(nums)) 
# 定义一个手机品牌的列表 
phone = ["HUAWEI", "OPPO"] 
print(type(phone))

9.2 快速生成数字列表

 range(起始值，结束值，步长) 

\# 生成一个包含1-100之间所有的整数的列表 

\# range 迭代对象 

nums = list(range(1, 101)) 

print(type(nums)) 

print(nums) 

\# 生成一个包含1-100之间所有的奇数的列表 

nums = list(range(1, 101, 2)) 

print(nums) 

\# 生成一个包含1-100之间所有的偶数的列表 

nums = list(range(2, 101, 2)) 

print(nums)

9.3 特点

• 有序
• 可变

9.4取值

# 定义一个手机品牌的列表 

phone = ["HUAWEI", "OPPO", "XiaoMi", "ViVO", "Apple", "MeiZu"] 

\#取出 MeiZu 

print(phone[-1]) 

列表切片 

\# 定义一个手机品牌的列表 

phone = ["HUAWEI", "OPPO", "XiaoMi", "ViVO", "Apple", "MeiZu"] 

\# 列表切片 

print(phone[:3]) 

\# 嵌套取值 

foods = [["广东", "肠粉"], ["东北", "水饺", ["10块钱一份", "便宜好 

吃"]], ["湖北", "热干面"]] 

print(foods[1][1]) # 取出水饺 

print(foods[-1][-1]) # 取出热干面 

print(foods[1][-1][0]) # 取出水饺的价格

9.5 常用方法

增加
追加元素到列表最后： append(元素) 
在指定的索引位置插入： insert(索引，值) 

nums = [3, 1, 2, 3] 
print(id(nums)) 
nums.append(4) # 追加 
nums.insert(0, "a") # 在指定的索引值前插入元素值 
print(nums)

删除
根据索引删除元素： pop(索引) ，不填则删除最后一个 
根据元素值删除元素： remove(值) ， 如果被删除的值存在多个，只会删除第一个 
nums.pop(0) # 根据指定索引值删除元素，不填索引值则删除最后一个元素 
print(nums) 
nums.remove(3) # 根据值移除元素，如果有多个，则删除第一个 
print(nums)

合并：加号 
a = [1, 2] 
b = [3, 4] 
c = a + b 
print(c)

修改：先取到值，再重新赋值 
a = [1, 2] 
a[1] = "B" # 先取到值，再重新赋值 
print(a) 

统计
nums = [4, 2, 1, 3, 9] 
print(max(nums)) # 最大值 
print(min(nums)) # 最小值 
print(len(nums)) # 统计有几个元素 

反转
b = [2, 1] 
b.reverse() # 反转列表 -- 自身翻转 
print(b[::-1]) # 反转列表（切片法） -- 新建一个列表翻转 

排序
# 从小到大 
nums.sort() 
# 从大到小 
nums.sort(reverse=True) 
print(nums)

字符串转列表 
a = '1234567' 
a = list(a) # 得到 ['1','2','3','4','5','6','7' ]

第十章 元组（tuple）

10.1 定义

元组也是Python中的一种基础数据结构，由 () 包围 
元组中可以存放任意类型的数据，每个数据被称作一个元素，元素之间用逗号隔开 
注意：当元组中只有一个元素时，必须要以逗号结尾，否则就不是元组 

nums = (1, 2, 3) 
print(type(nums)) 

10.2 特点

有序：有索引值
不可变：不能修改自身

10.3 常用方法

# 生成一个包含1-100之间的所有整数元组 
nums = tuple(range(1, 101)) 
print(nums) # 统计 
print(max(nums)) 
print(min(nums)) 
print(len(nums)) 
# 列表与元组互转 
nums = list(nums) # 元组-->列表 
nums.append(101) # 列表追加元素 
nums = tuple(nums) # 列表-->元组 
print(nums)

第十一章 字典（dict）

11.1 定义

字典是Python中的一种基础数据结构，由 {} 包围 
字典中的数据是以 键值对 的形式存在的，每个 键值对 被称作一个元素，元素之间用逗号隔开 
注意：字典中的键不能重复，否则只会保留最后一个；键不能使用可变类型的数据，否则会报错 

# 定义一个字典 
student = {"name":"zs", "age":19, "name2":"ls"} 
# print(type(student)) 
print(student)

11.2 特点

无序 == 3.7及以后字典有序

可变

11.3 常用方法

student = {"name":"zs", "age":19, "name2":"ls"} 
print(student["age"]) # 根据键取到值 
student["age"] += 1 # 根据键修改值 
student.pop("name2") # 根据键删除键值对 
student["name2"] = "ls" # 根据键修改值，如果键不存在，则自动添加 
print(student) 
# 获取所有的键 
print(student.keys()) 
# 获取所有的值 
print(student.values()) 
# 获取所有的键值对 
print(student.items()) 

11.4 总结:

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；

可变数据（3 个）：List（列表）、Dictionary（字典）、 Set（集合）

第十二章 选择语句（if）

12.1 程序的三大运行模式

12.2 if else

if 条件满足: 
    条件满足的时候做的事情1 
    条件满足的时候做的事情2 
    ... 
else: 
    条件不满足的时候做的事情1 
    条件不满足的时候做的事情2 
    ... 
    
 
# 酒吧：保安询问每个顾客的年龄，18岁及以上可以进入，否则不能进入 
age = int(input("请问您今年多大了？")) 
if age >= 18: 
    print("欢迎光临~") 
else: 
    print("抱歉，您不能进入~")

12.3 if嵌套

if 条件: 
    条件满足的时候做的事情1 
    条件满足的时候做的事情2 
    if 条件: 
        条件满足的时候做的事情 
    else: 
        条件不满足的时候做的事情 
else: 
    条件不满足的时候做的事情1 
    条件不满足的时候做的事情2 
    ...
    
    
age = int(input("请问您今年多大了？")) 
if 18 <= age <= 50: 
    print("欢迎光临~") 
    beer = input("请问您带了酒水吗？") # True False 
    if beer == "True": 
        print("请先将酒水交给我保管") 
        print("请跟我来") 
    else:
        print("请跟我来") 
else:
    print("抱歉，您不能进入~")

12.4 if elif

if 条件1: 
    条件1满足的时候做的事情 
elif 条件2: 
    条件2满足的时候做的事情
elif 条件3: 
    条件3满足的时候做的事情
... 
else: 
    以上条件都不满足时做的事情
    
    
    
print("欢迎使用它石牌BMI计算器~") 
weight = float(input("请输入您的体重(kg):")) 
height = float(input("请输入您的身高(m):")) 
bmi = round(weight / height ** 2, 1) 
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("您输入的信息有误~")
    
    
# 季节判断：输入任意月份，提示对应的季节 
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: 
elif month in (1, 2, 12): 
    print("冬季") 
else:
    print("您的输入有误~")

12.5猜拳游戏

import random # 导入随机数模块 
print("欢迎进入猜拳游戏~") 
player = int(input("请输入石头(0)剪刀(1)布(2)：")) 
computer = random.randint(0, 2) # 生成0-2之间的随机整数 
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("抱歉，您输了~")

第十三章 循环语句

13.1 while

while 条件: 
    条件满足时重复做的事情 
# 打印1-10之间的所有的整数 
num = 1 # 初始值
while num <= 10: 
    print(num) 
    num += 1 

# 打印1-10之间的所有的奇数 
# 类似步长写法 
i = 1 
while i <= 10: 
    print(i) 
    i += 2 
    
# 循环+判断写法 
i = 1 
while i <= 10: 
    if i % 2 != 0: 
        print(i) 
        i += 1 
        
# 打印1-10之间的所有的偶数 
# 类似步长写法 
i = 2 
while i <= 10: 
    print(i) 
    i += 2
    
# 循环+判断写法 
i = 1 
while i <= 10: 
    if i % 2 == 0: 
        print(i)
        i += 1 
        
# 输入任意5个整数，将它们按照从大到小的顺序排序并输出 
i = 1 
nums = [] 
while i <= 5: 
    num = int(input("请输入一个整数：")) 
    nums.append(num) 
    i += 1 
    nums.sort(reverse=True) 
print(nums) 
    
# 模拟一个登录系统，当用户为admin，密码为tashi123时登录成功，否则登录失败,最多只有三次机会 
print("欢迎来到它石管理系统~") 
i = 1 
while i <= 3: 
    username = input("请输入您的用户名：") 
    password = input("请输入您的密码：") 
    if username == "admin" and password == "tashi123": 
        print("登录成功") 
        break # 跳出循环 
    else: 
        print("登录失败") 
        i += 1 
        
# 猜数字：电脑随机给一个随机整数（0-5），用户输入数字进行猜测，机会无限制，猜对截止 
import random 
num = random.randint(0, 5) 
print(num) 
while True: 
    player = int(input("请输入您猜的数字：")) 
    if player == num: 
        print("恭喜您，猜对了~") 
        break 
    else: 
        print("抱歉，您猜错了") 
        
# 打印1-10(包含1 10)之间的所有数字，排除5 
i=0 
while i<10: 
    i+=1 
    if i%5==0: 
        continue 
    print(i)

13.1.1 双层循环

# 打印矩形 
i = 1 
while i <= 9: 
    print("*********") 
    i += 1 
    
# 打印矩形 （双层循环）
i = 1 
while i <= 9: 
    j = 1 
    while j <= 9: 
        print("*", end="") 
        j += 1 
    print() 
    i += 1 
    
# 打印三角形 （双层循环） 
i = 1 
while i <= 9: 
    j = 1 
    while j <= i: 
        print("*", end="") 
        j += 1 
    print() 
    i += 1 
    
# 打印九九乘法表 
i = 1 
while i <= 9: 
    j = 1 
    while j <= i: 
        print(f"{j}*{i}={j * i}", end="\t") 
        j += 1 
    print() 
    i += 1

13.2 for

格式

for 临时变量 in 序列/对象:

​ 重复做的事情

作用

一般用来 遍历 序列/对象

for循环次数与序列/对象的长度值一致

案例

# =======================遍历========================== 
# 字符串 
for i in "abc": 
    print(i) 
    
# 列表 
for i in [1, 2]: 
    print(i) 
    
# 元组 
for i in ("A", "B"): 
	print(i) 
    
# range
# 打印1-10之间的所有数字 
for i in range(1, 11): 
    print(i)
    
# 打印15次tashi 
for i in range(15):
    print("tashi") 
    
# 遍历所有键 
student = {"name":"zs", "age":19, "sex":"boy"}
for i in student.keys():
    print(i)     
# 遍历所有值 
for i in student.values(): 
    print(i) 
# 遍历所有键,值 
for x,y in student.items(): 
    print(x,y) 
    
#练习题     
# 现有student = {"name":"zs", "age":19, "sex":"boy"...},请将该数 据输出成name=zs，age=19... 
for k,v in student.items(): 
    print(f"{k}={v}")

练习题

# 输入任意5个整数，将它们按照从大到小的顺序排序并输出 
nums = [] 
for i in range(1, 6): 
    num = int(input(f"请输入第{i}个整数：")) 
    nums.append(num) 
    nums.sort(reverse=True) 
print(nums) 

# 模拟一个登录系统，当用户为admin，密码为tashi123时登录成功，否则登录失败 
# 最多只有三次机会 
print("欢迎来到它石管理系统~") 
for i in range(3): 
    username = input("请输入您的用户名：") 
    password = input("请输入您的密码：") 
    if username == "admin" and password == "tashi123": 
        print("登录成功") 
        break 
    else:print("登录失败") 
        
# 统计任意字符串的长度值，不能使用len() 
string = input("请输入需要统计长度的字符串：") 
num = 0 
for i in string: 
    num += 1 
print(f"该字符串的长度值是：{num}") 

# 统计任意字符串中的数字与字母的个数 
# abc123 
string = input("请输入需要统计长度的字符串：") 
num = 0 
letter = 0 
for i in string:
    # if i in "1234567890": 
    if i.isdigit(): 
        num += 1 
    # elif i in "abcdefghijklmnopqrstuvwxyzABCD...": 
    elif i.isalpha(): 
        letter += 1 
print("该字符串中，数字有{}个，字母有{}个".format(num,letter)) 

# 数7游戏：打印1-100之间的所有整数，不包含7的倍数以及数字中带有7的数字 
for i in range(1, 101): 
    # if i % 7 != 0 and "7" not in str(i): 
    if i % 7 != 0 and str(i).find("7") == -1: 
print(i) 
        
# 求1-100之间的偶数和 
res = 0 
for i in range(2, 101, 2): 
    res += i 
 print(res) 

# 现有a = 1, b = 2, 请将这两个变量的值交换 
a, b = 3, 5 
a, b = b, a 
print(a, b) 

# 斐波那契数列（兔子数列） 1 1 2 3 5 8 13 
# 生成24个斐波那契数列
nums = [] 
a, b = 0, 1 
for i in range(24): 
    nums.append(b) 
    a, b = b, a + b 
print(nums) 

# 0 1 1 2 3 5 8 13 
a = 0 
b = 1 
for i in range(10): 
    c = b + a 
    a = b 
    b = c 
    print(c) 
    
# 打印字符串 ，跳过l 
for i in 'Hello': 
    if i=='l': 
        continue 
    print(i)

双层循环

# 打印矩形 
for i in range(1, 10): 
    print("*********") 
    
# 打印矩形(双层循环) 
for i in range(1, 10): 
    for j in range(1, 10): 
        print("*", end="\t")
print() 

# 打印三角形 
for i in range(1, 10): 
    for j in range(1, i + 1): 
        print("*", end="\t") 
    print() 
    
# 打印九九表 
for i in range(1, 10): 
    for j in range(1, i + 1): 
        print(f"{j}*{i}={j * i}", end="\t") 
    print()

第十四章 函数

14.1 定义

函数本质上就是一段具有一定功能的并且可以重复使用的代码

通过 函数名() 调用函数

14.2 格式

def 函数名(): 
    代码块
    
案例
# 定义一个打印古诗的函数 
def print_gushi(): 
    print("白日依山尽") 
    print("黄河入海流") 
    print("欲穷千里目") 
    print("更上一层楼") 
print_gushi() # 调用函数

14.3 文档注释

文档注释一般情况用 一对三双引号/三单引号 表示

文档注释用来解释说明函数的作用

通过 help() 可以查看函数的文档注释

def print_poetry(): 
    """打印古诗：《登鹳雀楼》""" 
    print("白日依山尽") 
    print("黄河入海流") 
    print("欲穷千例目") 
    print("更上一层楼") 
help(print_poetry) # 查看函数的文档注释

14.4 函数的参数

形式参数： 函数定义时的参数

实际参数： 函数调用时传入的参数

# 定义一个函数，可以计算两数之和 
def func(a, b): # 形式参数 
    # a, b = 1, 2 
    print(a + b) 
func(12, 11) # 实际参数 
func(2, 11) # 实际参数

def feibo(n): 
    nums = [] 
    a, b = 0, 1 
    for i in range(n): 
        nums.append(b) 
        a, b = b, a + b 
        print(nums) 
feibo(15)

14.5 参数的传递方式

位置传递：形参与实参按照位置关系一一对应

参数的默认值：形参可以拥有默认值，有默认值的形参如果不传入实参则使

用默认值，有默认值的形参必须要放到没有默认值的形参的后面，否则会报错

关键字传递：通过指定形参名来传入值，可以不受位置关系的影响

def func(a, b=10): # 形式参数 
    print(a - b) 
func(12, 11) # 位置传递 
func(b=12, a=3) # 关键字传递，乱序传入 
func(9) # 默认值

14.6 返回值

函数使用 return 将执行结果返回给调用者，这就是返回值 ,

函数中如果没有 return ，那么返回值就为 None

函数一旦执行到 return ，就不会再继续往下执行

可以返回多个值 return a,b 默认是

def func(a, b): 
    return a + b # 返回值 

注意：一旦函数能够得到结果，都建议写返回值，将结果返回给调用者

# 猜一猜 为什么? 
def hi(name="xiaoming"): 
    def greet(): 
        return "now you are in the greet() function" 
    
    def welcome(): 
        return "now you are in the welcome() function" 
    
    if name == "xiaoming": 
        return greet 
    else:
        return welcome 
a = hi() 
print(a) # 打印的什么?? 
print(a()) # 为什么和上面的不一样

14.7 函数递归

#求一个数的阶乘 
def get_num(n): 
    if n>=2: 
        return n * get_num(n-1) 
    else:
        return n

14.8 全局&局部变量

局部变量： 定义在函数内部的变量，只在函数内部生效

全局变量： 定义在函数外部的变量，在整个代码文件中生效

可以使用 global 将局部变量声明成全局变量

num = 99 # 全局变量 
def func(a, b): 
    print(num) 
    global num2 # 将局部声明成全局变量 
    num2 = 80 # 局部变量 
    print(num2) 
    return a + b # 返回值 

func(1, 2) 
print(num) 
print(num2)

第十五章 异常处理

15.1 捕获异常

定义：当程序出现异常后，程序会终止运行。如果希望暂时先跳过这个异常，继续往后面执行，那么需要捕获异常。

格式 :

try:
    可能会出现异常的代码 
except Exception as e: 
    出现异常后执行的代码 
else:
    没有异常时执行的代码 
finally: 
    无论如何都要执行的代码

案例 :

print("开始了") 
# a = "a计划" 
b = "b计划" 
try:
    print(a) 
except Exception as e: 
    print("程序报错了，错误信息是：{}".format()) 
    print(b) 
else:
    print("没有任何异常") 
finally: 
    print("我始终都会执行") 
print("结束了")

15.2 抛出异常

定义：如果希望程序在指定情况下终止运行，那么则需要抛出异常。

格式： raise Exception(异常提示)

案例

print("程序开始了") 
num = int(input("请输入一个大于100的整数：")) 
if num > 100: 
    print("输入成功") 
else:
    try:
        raise Exception("输入有误，请输入一个大于100的整数！") 
    except Exception as e: 
        print("程序出现问题了，原因是：{}".format(e)) 
# 将错误日志写入到日志文件中 持久化保存日志 
print("程序结束了")

第十六章 文件操作

16.1 打开/创建文件

打开/创建文件使用 open（fifile，mode）

函数，该函数参数定义如下：

fifile ：文件名，可以是包含路径的文件名

mode ：文件打开模式

r ：只读模式，文件不存在则报错, 默认模式

w ：写入模式，文件不存在可以自动创建，会覆盖原内容

a ：追加模式，文件不存在可以自动创建

# 打开/创建文件 
file = open("test1.txt", "a") 
# 写入 
file.write("ABC") 
# 关闭文件 
file.close()

16.2 写入

# 写入 
file.write("ABC")

16.3 关闭文件

关闭文件使用 close()

检测文件是否关闭，可以使用 closed （已关闭返回True，未关闭返回False）

16.4 自动关闭文件

with open("gushi.txt", "w") as f: 
    f.write("白日依山尽\n黄河入海流") 
print(f.closed)

16.5 中文乱码处理

with open("gushi.txt", "w", encoding="utf-8") as f: 
    f.write("白日依山尽\n黄河入海流") 
print(f.closed)

16.6 读取

with open("gushi.txt", encoding='utf-8') as f: 
    # print(f.read()) # 读取所有内容 
    # print(f.read(3)) # 读取前三个字符 
    # print(f.read(3)) # 读取前三个字符，多次使用，会从上次读取位置继续往后读取 
    # print(f.readline()) # 按行读取，每次读一行 
    # print(f.readline()) # 按行读取，多次使用，会从上次读取位置继续往后读取
    print(f.readlines())

16.7 应用：文件备份

# 输入任意一个文件名，将其进行备份 
# 如：abc.txt abc-副本.txt 
# 1. 拿到需要备份的文件名（input） 
# 2. 组装新文件名 
# 3. 读取源文件 
# 4. 将读取内容写入到新文件 
file_name = input("请输入需要备份的文件名：") 
new_file = file_name.replace(".", "-副本.") 
# suoyin = file_name.find('.') 
# new_file = file_name[:suoyin] + "-副本" + file_name[suoyin:] 
# temp = file_name.split(".") 
# new_file = temp[0] + "-副本." + temp[1] 
with open(file_name, encoding='utf-8') as f: 
    res = f.read() 
with open(new_file, "w", encoding="utf-8") as f: 
    f.write(res) 
print("备份完成！")

16.8 大文件的读写

当文件比较大的时候,如果一次性 read,会造成内存负载过大,程序崩掉 
#打开文件 
file_name = input('请输入你要备份的文件名(text.txt):') 
index_a = file_name.find('.') 
file_name_new = file_name[0:index_a]+'.text_bak' 
file_old = open(r'C:\Users\Administrator\Desktop\text.txt','r') 
file_new = open(r'C:\Users\Administrator\Desktop\{}'.format(file_name_new),'w')



在线安装
在命令行中，输入 pip install 模块名 安装即可（若要指定版本号，模块名后加两个等号，再加版本号）
安装完成后，可以通过 pip list 去验证是否安装成功
如果因为下载超时导致安装失败，则指定国内下载源，如下：
手动安装
while True: content = file_old.read(1024) if len(content)==0: break file_new.write(content) file_old.close() file_new.close()

第十七章 模块

17.1 导入模块

import 模块 
from 文件/模块 import 函数/方法 
from 文件/模块 imp 
# import random # 导入整个模块 
# from random import randint # 从模块中导入某个函数 
from random import * # 导入模块中的所有方法 
# print(random.randint(0, 10)) 
print(randint(0, 10)) # 生成随机整数 
print(uniform(0, 10)) # 生成随机浮点数

17.2 安装模块

在线安装
在命令行中，输入 pip install 模块名 安装即可（若要指定版本号，模块名后加两个等号，再加版本号）
安装完成后，可以通过 pip list 去验证是否安装成功

如果因为下载超时导致安装失败，则指定国内下载源，如下：

pip install requests==2.24.0 -i https://mirrors.aliyun.com/pypi/simple/

手动安装

进入官网： https://pypi.org/ ，搜索并下载需要安装模块的压缩包 
解压下载好的压缩包，进入到解压好的目录中，确认有 setup.py 文件 
在当前位置打开命令行窗口，输入 python setup.py install 进行安装 
安装完成后，可以通过 pip list 去验证是否安装成功

17.3 常用模块

time

import time 
# 获取当前时间 
print(time.ctime()) # current time 
# 暂停/休眠 
time.sleep(0.5) 
# 获取当前时间，指定格式 2021-01-14 17:22:01 year month day hour minute second 
print(time.strftime("%Y-%m-%d %H:%M:%S"))

OS

import os 
# import shutil 
# 获取当前文件的路径 
print(os.getcwd()) # get current working directoryjson 
# 创建目录 
os.mkdir("tashi") 
# 删除目录 
os.rmdir("tashi") 
# remove 
# 删除文件 
os.remove(r"D:\202018\tashi\demo.txt") 
# shutil.rmtree("tashi") 

#执行其他程序文件 胶水语言的最好体现 (了解!!!) 
import os 
print('hello world') 
os.system("sh 1.sh")

json

res = '{"name":"zs", "age":19}' # json 
res = json.loads(res) # 将json-->dict 
print(type(res)) 
print(res["age"]) 
res["age"] += 1 
print(res) 
res = json.dumps(res) # 将dict-->json 
print(res) 
print(type(res))

第十八章 面向对象 == 封装 继承 多态

18.1 面向过程&面向对象

面向过程：按照业务逻辑从上往下编写代码，所有步骤都要亲力亲为（买鸭蛋… 吃烤鸭）

面向对象：将数据与函数绑定到一起，定义成 类， 通过类生成对象，减少代码编写，提高开发效率（买烤鸭）

18.2 类与对象

类：泛指一类事物

对象：单指某一个具体事物

18.3 类的组成部分

类名：这一类事物共同的名字

属性：这一类事物共同具有的特征 , 其实就是变量,只是放在了 类里面

方法：这一类事物具有的功能 , 其实就是函数,只是放在了 类里面

18.4 定义类

class Dog: # 类名大驼峰 
    # pass # 占位符 
    # 属性值 
    def eat(self): # 方法 
        print("狗正在吃东西") 
xiaohuang = Dog() # 创建对象，实例化 
xiaohuang.eat() # 对象调用类中的方法 
xiaohei = Dog() # 可以创建第二个对象 
xiaohei.eat()

18.5 初始化

class Dog: # 类名大驼峰, 经典类 新式类 
    # pass # 占位符 
    # 属性值 
    def __init__(self, color, weight): # 初始化方法, 初始化会在实例化时自动运行 
        self.color = color 
        self.weight = weight 
    def eat(self): # 方法 
        print(f"{self.color}的狗正在吃东西") 
    def run(self): 
        print(f"{self.weight}kg的狗正在跑") 
xiaohuang = Dog("黄色", 10) # 创建对象，实例化 
xiaohuang.eat() # 对象调用类中的方法 
xiaohuang.run()

18.6 继承

定义：

当一个类属于一个大类中的一小类，那么这个小类就可以继承大类。

小类被称作子类，大类即父类。

特点

子类可以使用父类中的所有方法

子类可以新增自己的方法

子类可以修改父类中的方法

class HaShiQi(Dog): 
    def chaijia(self): # 子类可以新增自己独有功能 
        print("哈士奇正在拆家") 
    def eat(self): # 子类可以修改父类中的方法 
        print("哈士奇正在咬骨头") 
xiaoha = HaShiQi("黑白相间", 15) 
xiaoha.eat() # 子类可以使用父类中的所有方法 
xiaoha.chaijia()

以面向对象编思想写计算器案例

class Calc: 
    def __init__(self, num1, num2): 
        self.num1 = num1 
        self.num2 = num2 
    def jiafa(self): 
        return self.num1 + self.num2 
    def jianfa(self): 
        return self.num1 - self.num2 
    def chufa(self): 
        return self.num1 / self.num2 
    def chengfa(self): 
        return self.num1 * self.num2

写代码，所有步骤都要亲力亲为（买鸭蛋… 吃烤鸭）

面向对象：将数据与函数绑定到一起，定义成 类， 通过类生成对象，减少代码编写，提高开发效率（买烤鸭）

18.2 类与对象

类：泛指一类事物

对象：单指某一个具体事物

18.3 类的组成部分

类名：这一类事物共同的名字

属性：这一类事物共同具有的特征 , 其实就是变量,只是放在了 类里面

方法：这一类事物具有的功能 , 其实就是函数,只是放在了 类里面

18.4 定义类

class Dog: # 类名大驼峰 
    # pass # 占位符 
    # 属性值 
    def eat(self): # 方法 
        print("狗正在吃东西") 
xiaohuang = Dog() # 创建对象，实例化 
xiaohuang.eat() # 对象调用类中的方法 
xiaohei = Dog() # 可以创建第二个对象 
xiaohei.eat()

18.5 初始化

class Dog: # 类名大驼峰, 经典类 新式类 
    # pass # 占位符 
    # 属性值 
    def __init__(self, color, weight): # 初始化方法, 初始化会在实例化时自动运行 
        self.color = color 
        self.weight = weight 
    def eat(self): # 方法 
        print(f"{self.color}的狗正在吃东西") 
    def run(self): 
        print(f"{self.weight}kg的狗正在跑") 
xiaohuang = Dog("黄色", 10) # 创建对象，实例化 
xiaohuang.eat() # 对象调用类中的方法 
xiaohuang.run()

18.6 继承

定义：

当一个类属于一个大类中的一小类，那么这个小类就可以继承大类。

小类被称作子类，大类即父类。

[外链图片转存中…(img-hWk3ixhc-1652326474991)]

特点

子类可以使用父类中的所有方法

子类可以新增自己的方法

子类可以修改父类中的方法

class HaShiQi(Dog): 
    def chaijia(self): # 子类可以新增自己独有功能 
        print("哈士奇正在拆家") 
    def eat(self): # 子类可以修改父类中的方法 
        print("哈士奇正在咬骨头") 
xiaoha = HaShiQi("黑白相间", 15) 
xiaoha.eat() # 子类可以使用父类中的所有方法 
xiaoha.chaijia()

以面向对象编思想写计算器案例

class Calc: 
    def __init__(self, num1, num2): 
        self.num1 = num1 
        self.num2 = num2 
    def jiafa(self): 
        return self.num1 + self.num2 
    def jianfa(self): 
        return self.num1 - self.num2 
    def chufa(self): 
        return self.num1 / self.num2 
    def chengfa(self): 
        return self.num1 * self.num2