Python-Python基本用法（全：含基本语法、用户交互、流程控制、数据类型、函数、面向对象、读写文件、异常、断言等)

1 环境准备

编辑器：Welcome to Python.org

解释器：pycharm：Thank you for downloading PyCharm! (jetbrains.com)

2 Quick start

1. 创建项目

• new project

• create

• demo

print('Dad!!')

3 基本语法

3.1 print

1. 直接打印

print('Dad!!')

2. 拼接打印

print('Hello'+' world'+'!')

3. 转义

print('He said "good"')
# 使用转义字符\，向右边
print('He said \"Let\'s go\"')

He said "good"
He said "Let's go"

4. 换行

• 不能直接换行，因此采用\n表示换行

print("Hello!\nHi!")

Hello!
Hi!

• ‘’'全部内容换行

print("""风萧萧兮易水寒，
壮士一去兮""")

风萧萧兮易水寒，
壮士一去兮

3.2 变量

1. 注意

先赋值变量，后使用

greet ="您好，吃了么"

print(greet+"张三")
print(greet+"李四")

您好，吃了么张三
您好，吃了么李四

2. 替代原来变量

greet ="您好，吃了么,"
greet_chinese = greet
greet_english = "Yo what's up,"
greet = greet_english
print(greet+"张三")
print(greet+"李四")

print(greet_chinese+"张三")
print(greet_chinese+"李四")

Yo what's up,张三
Yo what's up,李四
您好，吃了么,张三
您好，吃了么,李四

3. 变量名规则

• 只能由文字、数字、下划线组成

• 除下划线以外的符号不行

• 不能包含有空格

• 不能数字开头

• 变量名大小写敏感

• 关键字不能当作变量

3.3 数学运算

1. 符号

加减乘除：±*/

乘方：**

2. math工具包

• log

import math
result = math.log2(8)
print(result)

• sqrt

import math
a=-1
b=-2
c=3
print((-b+math.sqrt(b ** 2 - 4 * a * c))/(2 * a))
print((-b-math.sqrt(b ** 2 - 4 * a * c))/(2 * a))

-3.0
1.0

3.4 注释

1. 单行注释

# print("Hello!\nHi!") 

快捷键ctl+/

2. 多行注释

'''
我是多行注释
我是多行注释
'''

3.5 数据类型

1. 类型

str 字符串 ‘Hello’ “Hello”[3]获得第四个字符

int整数

float浮点数

bool布尔类型 True False

NoneType None表示完全没有值

type会返回对象的类型

2. 案例

# 对字符串求长度
s = 'Hello world!'
print(len(s))

# 通过索引获取字符串单个字符
print(s[1])
print(s[11])
print(s[len(s)-1])

# 布尔类型
b1 = True
b2 = False

# 空值类型
n = None

# type函数
print(type(s))
print(type(b1))
print(type(n))
print(type(1.5))

12
e
!
!
<class 'str'>
<class 'bool'>
<class 'NoneType'>
<class 'float'>

Process finished with exit code 0

3.6 运行模式

1. 命令行模式

针对文件一行一行解析和执行

2. 交互模式

直接一行出一个结果

cmd中输入python

• 运行

• 可以省略print

• 推出

quit()

或者ctrl+d

4 用户交互

1. input

input一律返回字符串

用int函数将返回的字符串转成整数int，同理，float也是把其他类型转换成浮点，str

2. 例子

# BMI = 体重/(身高**2)
user_weight = float(input("请输入你的体重(单位：kg):"))
user_height = float(input("请输入你的身高(单位：cm):"))
user_BMI = user_weight/(user_height)**2
print("您的BMI值为:"+str(user_BMI))

请输入你的体重(单位：kg):61
请输入你的身高(单位：m):158
您的BMI值为:0.0024435186668803075

5 流程控制

5.1 条件判断

1. 简单语法

if [条件]:
	[执行语句]  #前面有缩进，有四个空格
    [执行语句]

• 条件
  • 布尔类型
  • 逻辑运算符成立的:5>21

2. 真假判断

• 语法

if [条件]:    
    [执行语句]  #前面有缩进，有四个空格    
    [执行语句]
else:
    [执行语句]
    [执行语句]

• 案例

mood_index = int(input("对象今天的心情指数是:"))
if mood_index > 59:
    print("恭喜，今晚应该可以打游戏，去吧皮卡丘！")
else:# mood_index <= 59
    print("不可以打游戏！")

对象今天的心情指数是:85
恭喜，今晚应该可以打游戏，去吧皮卡丘！

3. 嵌套条件语句

• 语法

if [条件一]:
    if [条件二]:
        [语句A]
    else:
        [语句B]
else:
    [语句C]
# 注意缩进

• 案例

if mood_index < 60:
    if is_at_home
        print("放弃游戏，低调做人")
    else:
        print("自由！")

4. 多条件判断

• 语法

if [条件一]:
    [语句A]
elif [条件二]:
    [语句B]
elif [条件三]:
    [语句C]
else:
    [语句D]
# 如果多个条件满足，会根据自上而下的顺序执行第一个满足条件的语句

• 案例

# BMI = 体重/(身高**2)
user_weight = float(input("请输入你的体重(单位：kg):"))
user_height = float(input("请输入你的身高(单位：m):"))
user_BMI = user_weight/(user_height)**2
print("您的BMI值为:"+str(user_BMI))


if user_BMI <= 18.5:
    print("此BMI值属于偏瘦范围")
elif 18.5 < user_BMI <= 25:
    print("此BMI值属于正常范围。")
elif 25 < user_BMI <= 30:
    print("此BMI属于偏胖范围。")
else:
    print("此BMI值属于肥胖范围。")

请输入你的体重(单位：kg):61
请输入你的身高(单位：m):1.58
您的BMI值为:24.435186668803073
此BMI值属于正常范围。

5.2 逻辑运算

1. 逻辑运算符

• ==,!=,>,>=,<,<=

2. 案例

if (house_work_count > 10 and red_envelope_count >1 and shopping_count > 4 and not has_been_angry):
    print("摩拳擦掌等待Switch!")
else:
    print("Switch随风散去...")

5.3 循环

5.3.1 for循环

1. 基本for语法

• 语法

for xx in xx:
    语句

• 案例

temperature_dict = {"111":36.4,"112",36.6,"113",36.2}

for staff_id,temperature in temperature_dict.items():
    if temperature >= 38:
        print(staff_id)
        
for temperature_tuple in temperature_dict.items():
    staff_id = temperature_tuple[0]
    temperature = temperature_tuple[1]
    if temperature >= 38:
        print(staff_id)

2. for+range

• range

range(5):起始值默认为0

range(5,10):会给到5-9，不会给到10

range(5,10,2):起始值,结束值,步长

• 语法

for i in xxx:
    [语句]

• 案例

for i in range(1,101):
    total = total + i
print(total)

5.3.2 while循环

1. 语法

while 条件A:
    行动B

2. 循环语句比较

3. 实现一个小需求

用户持续输入一个数字并进行相加，等到输入q的时候，退出

• 自己写的垃圾代码

total = 0
while True:
    val = input("请输入数字：")
    if str(val) != 'q':
        total = total + int(val)
        print("目前总数："+str(total))
    else:
        break

• 正儿八经代码

total = 0
count = 0
val = input("请输入数字：")
while val != "q":
    total = total+int(val)
    count = count+1
    val = input("请输入数字：")
if count == 0:
    average = 0
else:
    average = total/count
print("目前总数：" + str(total))
print("平均值"+str(average))

6 数据结构

6.1 列表

1. 案例

shopping_list = ["键盘"，"键帽"] 
# 类比java数组，但是可以放不同数据类型的元素
list = ["Hello",66.6,True,None]

2. 方法

• append方法

shopping_list.append("显示器")

• remove方法

shopping_list.remove("显示器")

• len函数

len(shopping_list)

• 索引

print(shopping_list[0])  # 最后一个索引是列表长度减去一

#利用索引修改值
shopping_list[1] = "音响"

• 列表最大值、最小值，排序

print(max(num_list))
print(min(num_list))
print(sorted(num_list))

3. 特点

其他数据类型可变，列表不可变，即对列表进行了变化之后，会改变原来的原列表，不用对列表再进行赋值了

4. 实操

• 案例1

shopping_list = []
shopping_list.append("键盘")
shopping_list.append("键帽")
shopping_list.remove("键帽")

# 更新第一个元素
shopping_list[0] = "硬盘"
print(shopping_list)
print(len(shopping_list))
# 获取第一个元素
print(shopping_list[0])

['键盘']
1
硬盘

• 案例2

price = [799,1024,200,800]
max_price = max(price)
min_price = min(price)
sorted_price = sorted(price)
print(max_price)
print(min_price)
print(sorted_price)

1024
200
[200, 799, 800, 1024]

6.2 字典

1. 介绍

存储键值对，类比java的map

2. 语法

contacts = {"小明":"13000000000","小花":"137000000001"}

#查找
contacts["小明"]

# 更新元素到字典
contacts["小明"] = "18600000001"

# 添加元素到字典
contacts["美女A"] = "18600000000"

# 查看键是否已经存在,存在返回true，否则返回false
print("小明" in contacts)

# 删除一个键值对
del contacts["小明"]

• 键的数据类型是不可变的，列表可变的，因此就不能作为键的数据类型
• tuple是类似于列表的数据类型，不可变的,因此添加或者删除元素都不能操作的

contacts = {("张伟",23):"15000000000",
            ("张伟",34):"15000000001"
            ("张伟",34):"15000000001"}

zhangwei23_phone = contacts[("张伟"，23)]

3. 方法

temperature_dict = {"111":36.4,"112",36.6,"113",36.2}

#打印所有键
temperature_dict.keys()
#打印所有值
temperature_dict.values()
#打印所有键值对
temperature_dict.item()

4. 案例

slang_dict = {"觉醒年代":"觉醒吧少年",
              "YYDS":"永远的神"}

slang_dict["双减"]="减少学生作业负担和校外培训负担"

# 设置查询功能
query = input("请输入您想要查询的流行语:")
if query in slang_dict:
    print("您查询的"+"query"+"含义如下")
    print(slang_dict[query])
else:
    print("您查询的流行语暂未收录。")
    print("当前本词典收录词条数为："+str(len(slang_dict))+"条。")

请输入您想要查询的流行语:YYDS
您查询的query含义如下
永远的神

7 字符串简化

1. 案例1

• 原来

• format方法

在这里插入图片描述

简洁的方法

f"“”

xxx

“”"

2. 案例2
   

使用format方法的时候，{1}不用手动转为字符串了

{1:.2f}表示保留两位小

8 函数

8.1 函数基本知识

1. 引出

• 需求：扇形面积：*S扇=(n/360)πR²,

• 实现

2. 语法

def calculate_sector_1():
    # 定义函数的语句
    
# 调用函数
calculate_sector_1()

3. 案例

# 定义
def calculate_sector(central_angle,radius):
    sector_area = central_angle/360 * 3.14 * radius ** 2
    print(f"此扇形面积为:{sector_area}")
    
# 调用
calculate_sector(30,16)

4. 局部变量

• 场景

函数中的变量是局部变量，函数外访问不到

因此通过调用函数运行某段代码

因此return可以解决这个问题

如果方法没有return语句，那么返回的就是none

也例如一些自带得append和print函数，函数自己内部没有返回值，因此返回的是none

len()和sum()这些就是有返回值的，会给他赋值回一个变量

• 类比java

局部变量获取不到

return就获取得到了

• 优化案例

# 定义
def calculate_sector(central_angle,radius):
    sector_area = central_angle/360 * 3.14 * radius ** 2
    print(f"此扇形面积为:{sector_area}")
    return sector_area
    
# 调用
sector_area1 = calculate_sector(30,16)

5. 实操案例

def calculate_BMI(user_weight,user_height):
    user_BMI = user_weight/(user_height)**2
    # print("您的BMI值为:" + str(user_BMI))

    if user_BMI <= 18.5:
        print("此BMI值属于偏瘦范围")
    elif 18.5 < user_BMI <= 25:
        print("此BMI值属于正常范围。")
    elif 25 < user_BMI <= 30:
        print("此BMI属于偏胖范围。")
    else:
        print("此BMI值属于肥胖范围。")

    return user_BMI


print(calculate_BMI(61, 1.58))

此BMI值属于正常范围。
24.435186668803073

8.2 内置函数

1. python自带内置函数

2. 引入模块

• import引入statistics

import statistics
# 推荐，避免不同模块有相同名字的函数名，可以用模块名限制
print(statistics.median([19,-5,36]))
print(statistics.mean([19,-5,36]))

• from … import …语句

from statistics import median,mean
# 不需要带上模块的名字
print(median([19,-5,36]))
print(mean([19,-5,36]))

• from …import *

from statistics import *
# 不推荐，引入全部模块，太多了
print(median([19,-5,36]))
print(mean([19,-5,36]))

3. 安装模块

• 在pypi.org这个网站可以搜索第三方库

• 去重点使用pip install +库名安装

• 使用的时候import进来就可以了

9 面向对象

9.1 概述

1. 面向对象

• 类是创建对象的模板
• 对象是类的实例

2. 属性

• 获取对象属性

• 通过对象省略方法中的信息参数

3. 方法

4. 封装

只暴露方法/外部接口，内部实现细节隐藏起来，细节参照java的封装

5. 继承

类和类之间属性和方法相似，代码冗余，因此创建出一个父类，细节参照java

6. 多态

因为具体类的不同，各自的类有不同的表现，细节参照java

9.2 深入理解面向对象

1. 创建类

• 语法

class NameOfClass:
    # 定义类的代码

2. 定义属性

• 构造函数

class CuteCat:
    def_init_(self):# 方法名两下划线，构造方法第一个参数表示对象自身，固定的，类比java的this
        # 构造函数的代码

• 案例

class CuteCat:
    def _init_(self):
        self.name = "Lambton"
        
# 创建对象，会自己调用_init_方法，参数就不用再传self了
cat1 = CuteCat()

# 获取cat1的值
print(cat1.name)  # 会打印出来Lambton

更好的是可以从参数那边获取对象的属性值

class CuteCat:
    def _init_(self,cat_name):
        self.name = cat_name
        
# 创建对象，会自己调用_init_方法，参数就不用再传self了
cat1 = CuteCat("Jojo")

# 获取cat1的值
print(cat1.name)  # 会打印出来Jojo

多点属性

class CuteCat:
    def _init_(self,cat_name,cat_age,cat_color):
        self.name = cat_name
        self.age = cat_age
        self.color = cat_color

cat1 = CuteCat("Jojo",2,"橙色")

# 打印对象属性值
print(f"小猫{cat1.name}的年龄是{cat1.age}岁，花色是{cat1.color}")

3. 定义方法

• 定义方法

class CuteCat:
    def __init__(self,cat_name,cat_age,cat_color):
        self.name = cat_name
        self.age = cat_age
        self.color = cat_color
        
	def speak(self):# 第一个参数也是表示对象本身，固定的，这边的目的是可以继续获取或者修改对象绑定的属性
        # 方法的具体实现代码
        print("喵"* self.age)
        
     def think(self,content):
        print(f"小猫{self.name}在思考{content}...")
        
cat1 = CuteCat("Jojo",1,"橙色")
cat1.think("现在去抓沙发还是去撕纸箱")

• 小例子

# 定义一个学生类
# 要求：
# 1.属性包含学生姓名，学号以及语数英三科的成绩
# 2.能够设置学生某学科的成绩
# 3.能够打印出该学生的所有科目成绩

class Student:
    def __init__(self,name,number,score):
        self.name = name
        self.number = number
        self.score = score
        # 设置成字段形式
        self.grades = {"语文":0,"数学":0,"英语":0}

# 设置成绩
    def set_grade(self,course,grade):
        if course in self.grades:
            self.grades[course] = grade

# 打印所有成绩
    def print_score(self):
        print(f"学生{self.name}(学号:{self.number}的成绩为：)")
        for course in self.grades:
            print(f"{course}:{self.grades[course]}分")


xiaoming = Student("小明","1","99")
print(xiaoming.name)
xiaoming.print_score()
xiaoming.set_grade("数学",95)
print(xiaoming.grades)

# 改下yueyue的语文成绩
yueyue = Student("月月","2","60")
yueyue.set_grade("语文",99)
yueyue.set_grade("数学",92)
yueyue.print_score()

小明
学生小明(学号:1的成绩为：)
语文:0分
数学:0分
英语:0分
{'语文': 0, '数学': 95, '英语': 0}
学生月月(学号:2的成绩为：)
语文:99分
数学:92分
英语:0分

Process finished with exit code 0

9.3 继承

1. 设置继承

• 在类后面加上括号，括号中写上父类的名字

• 当创建子类实例时，优先调用子类的构造函数，导致只有has_tail的属性，没有父类构造器的属性，会在子类构造函数中调用父类的super()加上__init__

2. 案例

# 类继承练习：人力系统
# 员工分为两类：全职员工 FullTimeEmployee、兼职员工 PartTimeEmployee
# 全职员工和兼职员工都有“姓名 name”、“工号 id” 属性
# 都具备“打印信息print_info(打印姓名、工号)方法”
# 全职有“月薪 monthly_salary”属性
# 兼职有“日薪 daily_salary”属性、“每月工作天数 work_days”的属性
# 全职和兼职都有"计算月薪 calculate_monthly_pay" 的方法，但具体计算过程不一样


class Employee:
    def __init__(self,name,id):
        self.name = name
        self.id = id

    def print_info(self):
        # print("打印姓名"+self.name+"打印工号"+self.id)
        print(f"员工名字:{self.name},工号:{self.id}")


class FullTimeEmployee(Employee):
    def __init__(self,name,id,monthly_salary):
        super().__init__(name,id)
        self.monthly_salary = monthly_salary

    def calculate_monthly_pay(self):
        return self.monthly_salary


class PartTimeEmployee(Employee):
    def __init__(self,name,id,daily_salary,work_days):
        super().__init__(name,id)
        self.daily_salary = daily_salary
        self.work_days = work_days

    def calculate_monthly_pay(self):
        return self.daily_salary*self.work_days

# 实例化
zhangsan = FullTimeEmployee("张三","1001",6000)
lisi = PartTimeEmployee("李四",1002,230,15)
zhangsan.print_info()
print(zhangsan.calculate_monthly_pay())
lisi.print_info()
print(lisi.calculate_monthly_pay())

员工名字:张三,工号:1001
6000
员工名字:李四,工号:1002
3450

10 读写文件

10.1 读文件

1. 读文件(定位文件)

open("绝对/相对路径",模式,编码方式)
f = open("./data.txt","r",encoding="utf-8")
常见模式:r 只读
    	w 只写
异常：读不到会报错：FileNotFoundError

2. 读取文件方法

• read()方法

# 读取全部文件
print(f.read())
第二次.read()发现文件为空

# 读取规定字节文件
print(f.read(10))

• readline读取

# 读取一行内容
print(f.readline()) # 背后根据换行符判断行结束并读取

f = open("./data.txt","r",encoding="utf-8")
line = f.readline()

while line !="": # 判断当前行是否为空
    print(line)
    line = f.readline()

• readlines()方法

f = open("./data.txt","r",encoding="utf-8")
lines = f.readlines()	# 把每行内容储存到列表里
for line in lines:	# 遍历每行内容
    print(line)	# 	打印当前行

3. 关闭文件

• close()关闭

f = open("./data.txt")
print(f.read()) # 对文件的操作

f.close()

• with关闭

with open("./data.txt") as f:
    print(f.read())

4. 案例

# read和close
f = open("./data.txt","r",encoding="utf-8")
content = f.read()
print(content)
f.close()


# 或者readline

with open("./data.txt","r",encoding="utf-8") as f:
    line = f.readline()

    while line != "":
        print(line)
        line = f.readline()


# readlines
with open("./data.txt","r",encoding="utf-8") as f:
    lines = f.readlines()
    for line in lines:
        print(line)

10.2 写文件

1. 写文件(定位文件)

with open("./data.txt","w") as f:

如果写的文件不存在，程序就会自动创建文件，不会报错

写入模式：
"w"：覆盖清空原文件后写入
"a":表示附加内容，不会清空原来的
    
但是如果使用的w或者a，就不能用read()模式

"r+":就可以同时支持读写文件，并且时追加形式

2. write写文件

f.write("Hello!")
f.write("Yoooo")

Hello!Yoooo # 不会帮你换行的，需要手动增加换行符

3. 案例

# 任务1：在一个新的名字为"poem.txt"的文件里，写入以下内容
# 我欲乘风归去，
# 又恐琼楼玉宇，
# 高处不胜寒。

with open("./poem.txt","w",encoding="utf-8") as f:
    f.write("我欲乘风归去，\n")
    f.write("又恐琼楼玉宇，\n")
    f.write("高处不胜寒。\n")

# 任务2：在上面的"poem.txt"文件结尾处，添加以下两句：
# 起舞弄清影，
# 何似在人间。

with open("./poem.txt","a",encoding="utf-8") as f:
    f.write("起舞弄清影，\n")
    f.write("何似在人间。\n")

我欲乘风归去，
又恐琼楼玉宇，
高处不胜寒。
起舞弄清影，
何似在人间。

11 捕捉异常

1. 异常案例

12 断言

1. 概念

assert 断言：后面跟上布尔表达式，会在后面跟上认为为true的表达式。如果不对，就会出现AssertError,程序终止

2. 单元测试库

unittest

import test

TestMyAdder类并作为unittest.TestCase的子类

在里面的方法都是测试用例，方法名字都是用test_开头，不然unittest只认这个test_开头

使用assertEqual方法，调用父类的方法，是TestCase的方法

然后在编辑器终端输入运行，并展示测试结果

python -m unittest

通过是…

没通过是F.

3. 常用测试方法

在这里插入图片描述

4. setup简化实例化测试写法

5. 案例

• 代码

  

• 测试方法

  

• 运行

通过

不通过