Python闯关升级

1. 什么是Python?

Python由荷兰人吉多·范罗苏姆，于1990 年代初设计

python是编程语言的一种

高级语言又有很多种，比如 C++、Java、C#、PHP、JavaScript 等，Python 也是其中之一

Python 2于2000年10月16日发布，稳定版本是Python 2.7。

Python 3于2008年12月3日发布，不完全兼容Python 2。

2. Python - 编写规范

1.缩进做到统一，不建议用tab，不要混用（建议用4个空格来缩进代码）

2.如果一个文本字符串在一行放不下, 可以使用圆括号来实现隐式行连接

x = ('这是一个非常长非常长非常长非常长 '
'非常长非常长非常长非常长非常长非常长的字符串')

3.不要在逗号, 分号, 冒号前面加空格, 但应该在它们后面加(除了在行尾)
4.参数列表, 索引或切片的左括号前不应加空格

3. Python - 算数运算符

运算符|描述|实例
–|–|–|–

|加 | 10+20=30
-|减|10-20=-10
|乘|1020=200
/| 除|10/20=0.5
//| 取整| 10//20=0
%| 取余数|10%20=0
| 平方计算|23=8

优先级

1、先乘除后加减，同级从左到右，（）优先计算
2、（** 幂）高于（ * / % // ）高于（ + -）

4. Python - 变量介绍

变量类型和命名

分为：数字型和非数字型

1）数字型

整数 int
浮点型 float （%.2f 保留小数点后两位）
布尔型 bool (True Flase)

2）非数字型

字符串 str (注意：字符串和整数不能相加，字符串之间相加 =连接)
列表 list
元组 tuple
字典 dict

变量命名就是通过标识符进行赋值，比如name = ‘xiyu’ ，name就是标识符，xiyu就是赋的值。

一、规则：
1）标识符可以是数字、字母和下划线组成
2）标识符不能以数字开头
3）标识符不能以关键字命名（关键字主要是python内部已经使用的标识符）
4）区分大小写

二、方式：
1）小驼峰（第一个单词小写，后续单词首字母大写） mail firstName
2）大驼峰（每一个单词首字母都是大写） FirstName

案例

mail = 123456789
mailKey = 123456
name = 'xiyu' #如果变量赋值为字符串，需要使用引号print(mail)
print(mailKey)
print（name）price = 4.5
weight = 7.8
money = price * weight
print(money)

5. Python - input函数

案例

price_str = input("请输入苹果价格:")
price = float(price_str)  #默认的字符串转为浮点型weight_str = input("请输入重量：")
weight = float(weight_str)  #默认的字符串转为浮点型
money = price * weightprint(money)

6. Python - 格式化输出

格式

%s 字符串
%d 十进制整数
%f 浮点数
%% 输出%

语法： print(‘格式化字符串’ % 变量1)
语法： print(‘格式化字符串’ % （变量1，变量2…)))
语法： print(f’格式化字符串{变量1},{变量2}') #f格式化输出是python3.6新增方法。

案例

name = 'xiaoyu'
print('我的名字叫%s,请多多关照' % name)stu_number = 123
print('我的学号是:%d' % stu_number)

price = float(input('苹果的单价是：'))
weight = float(input('苹果的重量为：'))
money = price * weight
print('苹果的单价是：%.2f，苹果的重量是：%.2f，苹果的总价是：%.2f' %(price, weight, money))   #%.2f代表小数点保留2位，%.3f代表小数点保留3位

7. Python - 条件判断（if循环）

格式

if 要判断的条件：条件成立时，要做的事情
else条件不成立时，要做的事情

案例

age = 3
if age >= 3 :print('可以入学幼儿园')
else:print('年龄太小，回家玩吧')

案例

age = int(input('请输入年龄：'))  #将默认字符转为int类型
if age >= 3 :print('可以入学幼儿园')
else:print('年龄太小，回家玩吧')

elif

time = int(input('请输入时间点（1）代表1点，（20）代表20点:'))
if time >= 6 and time < 12:print('您输入的时间是%s点 现在是上午' % time)
elif time >= 12 and time <= 12:print('现在是中午')
elif time >= 13 and time < 18:print('现在是下午')
else:print('现在时间是晚上')

8. Python - 逻辑运算

and

案例

age = int(input('请输入年龄：'))
if age >= 3 and age <=6 :print('可以入学幼儿园')
else:print('年龄太合适，回家去吧')

age = int(input('请输入年龄：'))
if age <= 5 or age >=22 :print('可以进幼儿园')
else:print('年龄太合适，回家去吧')

not

student = True  # bool型分为True和False，True代表是学生
if not student:print('请不要进入校园')  #取反
else :print('请进入校园')

9. Python - random模块

案例
在7.4案例的基础上import导入一个随机数模块random，从1-24中随机取值

import random
print(random.randint(1, 24))

10. Python - 条件判断（while循环）

案例

i = 1   #声明一个变量
while i <= 5:     #关键字while 后面跟一个条件print('Hi,同学好')i += 1    #执行打印一次后，给他一个条件
print('循环结束后的值为 %d' % i)

死循环

i = 0
while True:i += 1print('这是一个死循环：%d' % i)

自然计数法：从1开始
程序计数法：从0开始

案例
计算0-100所有数字的和

i = 0
result = 0
while i<= 100:print(i)result += ii += 1
print('所有数字的和为: %d ' % result)

案例
计算0-100所有偶数数字的和

i = 0
result = 0
while i<= 100:print(i)result += ii += 2
print('所有偶数的和为: %d ' % result)

或者

i = 1
result = 0
while i <= 100:if i % 2 ==0:print(i)result += ii += 1else:i += 1
print('所有偶数的和为: %d ' % result)

while循环嵌套

while 条件1：条件满足时，做的事情1条件满足时，做的事情1条件满足时，做的事情1while 条件2：条件满足时，做的事情1条件满足时，做的事情1条件满足时，做的事情1处理条件2处理条件1

9*9乘法表

y = 1   #y 代表行数，最大9行
while y <= 9:x = 1while x <= y:print("%d * %d = %d" %(x, y, x*y),end="\t")x += 1print("")y += 1

11. Python - 终止循环（break和continue）

break

i = 0
while i <= 10:  #当i == 5的时候直接中断，并且不打印，所以只打印到4if i == 5:breakprint(i)i += 1
print("over")

continue

i = 0
while i <= 10:if i == 5:  #当i等于5时，它会中断(意思就是这次不打印了)，但是由于下面的continue，它会继续，直到i<=10 就会整体中断i += 1continue  #只作用域if循环 而且i == 5的那一次print(i)i += 1
print("over")

12. 列表

List （列表）是python中最频繁的数据类型，专门用于存储一串信息

列表中[] 定义，数据之间用 , 分隔

列表索引从0开始

索引就是数据在列表中的位置编号，又被称为下标

下标除了列表使用到之外，还有列表、元组都会使用到

序号	分类	函数/方法	说明
1	增加-	列表.insert(索引，数据)	在指定位置插入
-	-	列表.append(数据)	末尾插入
-	-	列表.extend(列表2)	将列表2的数据追到的列表
2	修改	列表.[索引]=数据	修改指定索引数据
3	删除	del列表[索引]	删除指定索引数据
-	-	列表.remove[数据]	删除第一个出现的指定数据
-	-	列表.pop	删除末尾数据
-	-	列表.pop(索引)	删除指定索引数据
-	-	列表.clear	清空列表
4	统计	len(列表)	列表长度
-	-	列表.count(数据)	数据在列表中出现的次数
5	排序	列表.sort()	升序排序
-	-	列表.sort(reverse=True)	降序排序
-	-	列表.reverse()	逆序反转

定义序列

name_list = ["小明", "小夏", "小红"]   #定义列表
print(name_list)

插入

name_list.insert(0, "小亮")  #在下标0前面插入数据
name_list.insert(2, "小胡")  #在下标2前面插入数据
name_list.append("小末")     #末尾添加
print(name_list)

清空列表

name_list.clear()  #清空列表
print(name_list)

统计长度

name_list = ["小明", "小夏", "小红"]
print(len(name_list))  #索引计数从0开始，但是统计长度从1开始

统计出现次数

name_list = ["小明", "小夏", "小红"]
name_list.append("小明")
print(name_list)
print(name_list.count('小明'))

升降序

number_list = [2, 4, 1, 5, 3, 7, 6, 9, 8]
print(number_list)number_list.sort()  #升序
print(number_list)number_list.sort(reverse=True)  #降序
print(number_list)number_list.reverse()  #逆序
print(number_list)

循环取值

number_list = [2, 4, 1, 5, 3, 7, 6, 9, 8]
for i in number_list:print(i)print(type(i))

列表合并

number_list_1 = [1, 2, 3]
number_list_2 = [4, 5, 6, 7]
number_list_1.extend(number_list_2)  #将列表2追加到列表1中
print(number_list_1)number_list_1 = [1, 2, 3]
number_list_3 = ['小虎','小七']
number_list_1.extend(number_list_3)
print(number_list_1)

13. 元组

Tuple 元组与列表类似，不同之处元组的元素不能修改

元组表示多个元素组成的序列

元组再python开发中，有特定的应用场景

用于存储一串信息，数据之间使用，分隔

元组用（）定义

元组的索引从0开始

索引就是数据在元组中的位置编号
info_tuple = (“xiaohu”,22,1.82)

创建空元组

info_data = ()
print(info_data)

元组中只包含一个元素时，需要在最后加逗号

info_data = (100,)      #如果不加逗号，类型为int，非tuple

元组常用操作

count统计元组中出现的元素的次数

info_date_1 = (1, 2, 3, 4, 5, 1, 1)
print(info_date_1.count(1))     #d得到的结果就是3，3个1

index 指的是当前元素的下标

info_date_2 = (1, 2, 3, 4, 5, 1, 1)
print(info_date_2.index(4))     #从0开始计算，4的下标就是3

循环遍历

info_date_1 = (1, 2, 3, 4, 5, 1, 1)
for i in info_date_1:print(i)print(type(i))

类型转换

info_date_1 = (1, 2, 3, 4, 5, 1, 1)
print(type(info_date_1))
print(type(list(info_date_1)))
print(type(tuple(info_date_1)))

14. 字典

dictionary（字典）是除列表以外最灵活的数据类型

存储多个数据，通常描述一个物体的相关信息

列表是有序的对象集合，字典是无序的对象集合

用 {} 定义

使用键值对存储数据，用 , 分隔
键 key 是索引

值 value 是数据

key value 使用：分隔

键值必须唯一

值可以是任何数据类型，键只能是字符串、数字或者元组

案例

xiaoming = {"name" : "小明","age" : "22","gender" : "True","height" : "1.82"}print(xiaoming)
print(type(xiaoming))   #返回是dict类型

查找

xiaoming = {"name" : "小明","age" : "22","gender" : "True","height" : "1.82"}print(xiaoming)
print(type(xiaoming))
print(xiaoming['name'])             #返回名字
#print(xiaoming.['address'])          #因为没有元素，会报错
print(xiaoming.get('address'))        #使用get不会报错 返回None
print(xiaoming.keys())              #返回key值
print(xiaoming.values())            #返回value值
print(xiaoming.items())             #返回所有的k-v

修改

xiaoming['name'] = 'xiaohong'  #将name中的xiaoming改成xiaohong
print(xiaoming)

删除

del xiaoming['gender']
print(xiaoming)

随机删除

print(xiaoming.popitem())
print(xiaoming)

循环

for k,v in xiaoming.items():print(k,v)for k in xiaoming:print("%s: %s" % (k, xiaoming[k]))   #[k]内部不加引号

其他
xiaoming.clear
xiaoming.items
xiaoming.popitems
xiaoming.setdefault
xiaoming.copy
xiaoming.keys
xiaoming.value
xiaoming.update
xiaoming.fromkeys
xiaoming.pop
xiaoming.get

15. 列表、元组和字典对比

对比表

类型	列表	元组	字典
定义	List （列表）是python中最频繁的数据类型，专门用于存储一串信息	与列表类似，不同之处元组的元素不能修改	dictionary（字典）是除列表以外最灵活的数据类型,存储多个数据，通常描述一个物体的相关信息
灵活性	最频繁	不灵活	最灵活
修改	可修改	不可修改	可修改
定义符	[]	()	{}
索引	有	有	有
分隔符	,	,	,
是否有键值	无	无	有

16. 字符串

字符串就是一串字符

python中可以使用一对双引号或者单引号定义
可以使用\ " 或者 '进行转义
- 如果字符串内部用 ” 可以使用 ’ 定义字符串
- 如果字符串内部用 ‘ 可以使用 “ 定义字符串
可以使用索引获取一个字符串中的位置，索引从0开始
也可以使用for 循环遍历

定义for循环

str_test= "hello world"   #for循环
for s in str_test:print(c)

切片

str_test = "hello world"
print(str_test[1])      #切片
print(str_test[1:])     #按照切片取值，从1开始到最后
print(str_test[1:6])    #按照切片取值，从1开始到6

大小写

str_test = "hello world"  #定义string
s1 = str_test             #定义为s1
print(s1.capitalize())    #用capitalize方法进行开头大写
print(s1.title())         #用title方法将每个单词首字母都大写
print(s1.upper())         #用upper方法将所有单词都大写

str_test_01 = "HELLO world"
s2 =str_test_01
print(s2.lower())   #用lower方法将所有单词都小写

find 查找

str_test = "hello world"
print(str_test.find('or'))  #查找内容中or的索引
print(str_test.find('a'))   #如果不存在返回 -1

index 查找

str_test = "hello world"
print(str_test.index('or'))  #查找内容中or的索引
print(str_test.index('a'))   #如果不存在返回ValueError: substring not found

find 和 rfind 查找

s = 'hello good world'
print(s.find('o'))   #从前向后查找 首次o出现的位置，所以索引坐标为4print(s.find('o', 5))   #从前向后查找 从5开始查找o出现的位置,索引坐标为7print(s.rfind('o'))   #从后向前查找 首次o出现的位置，所以索引坐标为12

性质判断

str_test = "hello world!"print(str_test.startswith('He'))  #判断开始否是He开头，不是则返回Falseprint(str_test.startswith('hel'))  #判断开始否是hel开头，是则返回Trueprint(str_test.endswith('!'))       #判断末尾否是！结尾，是则返回True

字母、数字构成判断

str_test_01 = "abcd1234"
print(str_test_01.isdigit())  #判读是否纯数字，返回True和False
print(str_test_01.isalnum())  #判读是否是数字和字母构成，返回True和Falsestr_test_02 = "1234"
print(str_test_02.isdigit())  #判读是否纯数字，返回True和False
print(str_test_02.isalpha())  #判读是否字母构成，返回True和False

格式化字符串

a = 123
b = 321
print('%d * %d = %d' % (a, b, a * b))            #第一种方式
print('{0} * {1} = {2}'.format(a, b, a * b)) #第二种方式
print(f'{a} * {b} = {a * b}')                #第三种方式，python3.6开始在字符串之前用f格式化字符串
#输出
123 * 321 = 39483
123 * 321 = 39483
123 * 321 = 39483针对f格式化，常用以下方式
print(f'{3.1415926:.3f}')     #格式化输出保留小数点
print(f'{a:.3f}')
print(f'{a:0>10d}')                #向左补0，补够10位
print(f'{a:>10d}')             #向左补空格，补够10位
print(f'{a:.2%}')             #百分比格式
#输出
3.142
0000000123123
12300.00%

格式化 - 对齐

str_test = 'hello world'
print(str_test.center(20,'*'))      #补齐20个字符，不够用*补齐
print(len(str_test.center(20,'*'))) #查看长度print(str_test.rjust(20))   #右对齐
print(str_test.ljust(20))   #左对齐print('33'.zfill(5))    #字符串左侧补0
print('-33'.zfill(5))    #字符串左侧补0，负号有算一个字符

字符串修剪

str_test ='   aliyun.com   \t\n\r  '
print(str_test.strip())     #strip方法将左右两侧特殊字符和空格修剪掉
print(str_test.rstrip())    #将右侧修剪掉
print(str_test.lstrip())    #将左侧修剪掉

替换

str_test ='hello world'
print(str_test.replace('o', '@'))     #replace方法将o替换成@
print(str_test.replace('o', '@', 1))     #replace方法将第一个o替换成@

合并

str_test = 'i love you'
print(str_test)             #打印
print(str_test.split())     #拆分后的字符 变成了一个列表
words = str_test.split()   #将添加,号之后的内容赋值给words
print('#'.join(words))        #将列表用join方法对words进行组合，使用#进行组合
#输出
i love you
['i', 'love', 'you']
i#love#you

拆分

str_test = 'i#love#you#so#much'   #字符串用#连接一起
print(str_test)                 #打印
words = str_test.split('#')      #使用split对#进行拆分
print(words)                    #打印#输出
i#love#you#so#much
['i', 'love', 'you', 'so', 'much']

编码/解码

python中除了字符串外，还有一种表示二进制数据的字节串类型（bytes），由零个或者多个字节组成的有限序列
1、通过字符串的encode方法，可以按照某种编码方式将字符串编码为字节串
2、也可以通过字节串的decode方法，将字节串解码为字符串

a = '熙雨'                  #定义a
b = a.encode('utf-8')        #使用encode对a进行编码
c = a.encode('GBK')          #编码，大小写均可
print(b,c)print(b.decode('utf-8'))    #解码，需要用同样的方法
print(c.decode('gbk'))        #解码

17. 集合

集合是除列表、元组后的另一种数据类型，名字叫集合（set）
- 无序性：一个集合中，每个元素地位相同，元素之间是无序的
- 互异性：一个集合中，不会出现两个重复的元素
- 确定性：一个集合中，一个元素要么属于它，要么不属于它

列表和集合间可以相互转换，set本身有去重功能

创建集合

data_list = {1,2,3,4,5,6,5,4,3,2,1}
print(data_list)
#输出
{1, 2, 3, 4, 5, 6}      #集合有去重功能data_list = {}         #如果定义了一个空值，那么默认是dict字典，除非用set定义
print(type(data_list))
#输出
<class 'dict'>data_list = set()            #如果定义了一个空值，需要用set
print(type(data_list))
#输出
<class 'set'>

循环遍历

set_list_1 = {num for num in range(1, 20) if num % 3 ==0}  #判断符合条件的数字
print(set_list_1)               #打印集合
print(type(set_list_1))         #打印类型
for i in set_list_1:            #遍历 print(i)print(type(i))              #遍历后类型为int 整数类型

成员运算

成员运算：通过成员运算 in 和not in 检查元素是否在集合中

set1 = {1, 2, 3, 4, 5, 6}       #定义一个集合
print(1 in set1)            #如果1 在集合中返回True
print(7 in set1)            #如果7在集合中返回True，不在就返回False
print(7 not in set1)        set2 = {'python','c++','java'} #不仅数字，字符也可以
print('python' in set2)
print('go' in set2)#输出
True
False
True
True
False

交并差运算

交并差运算：跟数学上集合一样，可以进行交集并集差集进行运算

set1 = {1, 2, 3, 4, 5, 6, 7}
set2 = {2, 4, 6, 8, 10}print(set1 & set2)              #第一种方式计算交集
print(set1.intersection(set2))  #第二种方式计算交集，结果同上print(set1 | set2)              #第一种方式计算并集，由于集合不允许重复，所以重复的不显示
print(set1.union(set2))         #第二种方式计算并集，由于集合不允许重复，所以重复的不显示print(set1 - set2)              #第一种方法计算差集
print(set1.difference(set2))    #第二种方式计算差集print(set1 ^ set2)              #第一种方式计算对称差
print(set1.symmetric_difference(set2))      #第二种方式计算对称差
print((set1 | set2) - (set1 & set2))        #第三种方式计算对称差（并集-交集=对称差）#输出
{2, 4, 6}           交集
{2, 4, 6}           交集
{1, 2, 3, 4, 5, 6, 7, 8, 10}    并集
{1, 2, 3, 4, 5, 6, 7, 8, 10}    并集
{1, 3, 5, 7}        差集
{1, 3, 5, 7}        差集
{1, 3, 5, 7, 8, 10}     对称差
{1, 3, 5, 7, 8, 10}     对称差
{1, 3, 5, 7, 8, 10}     对称差

比较运算

两个集合可以用 == 和 != 进行相等性判断
1、如果两个元素完全相同，结果是True，否则False
2、如果集合A的任意一个元素都是集合B的元素，那么A是B的子集，B是A的超集

set1 = {1, 3, 5}
set2 = {1, 2, 3, 4, 5}
set3 =set2
print(set1, set2, set3)# <运算符表示真子集，<=代表子集
print(set1 < set2) #1为2的真子集
print(set1 > set2)
print(set1.issubset(set2))      #通过issubset判断子集,等同<=
print(set1 <= set2)
print(set2.issuperset(set1))    #通过issuperset判断超级，等同>
print(set2 > set1)
print(set2 <= set3)#输出
{1, 3, 5} {1, 2, 3, 4, 5} {1, 2, 3, 4, 5}
True
False
True
True
True
True
True

集合方法

python中的集合是可变类型，可以通过集合方法为集合添加或者删除元素

集合方法 - 增加

set1 = set()        #定义空集合
set1.add(22)        #添加元素
set1.add(33)        #添加元素
print(set1)

集合方法 - 更新/添加

set1.update({1, 2, 3, 4, 5})    #更新新增元素
print(set1)

集合方法 - 删除

set1.discard(1) #如果删除的元素不存在，也不会报错，跟remove的区别
print(set1)set1.remove(2)  #如果删除的元素不存在，会报错，建议使用if判断删除，就算不存在也不会报错
print(set1)
if 3 in set1:set1.remove(3)
print(set1)print(set1.pop()) #使用pop方法随机删除一个元素并返回这个元素
print(set1.clear())     #全部清空，返回None#输出
{33, 22}
{33, 1, 2, 3, 4, 22, 5}
{33, 2, 3, 4, 22, 5}
{33, 3, 4, 22, 5}
{33, 4, 22, 5}
33
None

集合方法 - 判断相同

#判断两个集合有没有相同元素，可以使用isdisjoint方法，没有的话返回True,否则返回False
set1 = {'java','python','go','c++'}
set2 = {'c++','c','css','html'}
print(set1.isdisjoint(set2))  #因为1和2中有相同的c++元素，因此返回False#输出
False

不可变集合

python中还有一种不可变类型的集合，叫frozenset，set跟frozenset的区别就如同list和tuple一样，frozenset由于是不可变类型，能够计算出哈希码，因此它可以作为set中的元素。除了不能添加和删除原酸，frozenset在其他方面与set基本一样

set1 = frozenset({1, 3, 5, 7})          #定义set1
set2 = frozenset(range(1, 6))      #定义set2
print(set1, set2)   print(set1 | set2)                  #并集
print(set2 & set2)                  #交集
print(set1 - set2)                  #差集
print(set1 < set2)                   #子集#输出
frozenset({1, 3, 5, 7}) frozenset({1, 2, 3, 4, 5})
frozenset({1, 2, 3, 4, 5, 7})
frozenset({1, 2, 3, 4, 5})
frozenset({7})
False

python的集合底层使用了哈希存储的方式，具体原理不做介绍，现阶段了解集合是一种容器，元素必须是hashable类型就好，与列表不同的地方在于集合中元素没有序，不能用索引运算，不能重复。

18. 函数

18.1 函数的基本使用

什么是函数？

把具有独立功能的代码块，组织为一个小模块，在需要的时候进行调用

函数格式

def 函数名():函数封装的代码...

1、def是英文define的缩写
2、函数名应该能够表达函数封装代码的功能，方便后续调用
3、函数名称的命名应该符合标识符的命名规则

可以由字母、数字、下划线组成
不能以数字开头

18.2 函数的调用

#定义函数
"""
说明：此处是对函数添加注释，定义函数的作用和目的
"""
def weekend():print("it's a nice day today")print('I want to go out')
#调用函数
weekend()

注意：函数调用必须放在定义函数之后

PyCharm调试工具

注意：鼠标左键点中左侧后，出现红点，然后进行debug，可以查看单步执行结果。

函数注释

在 定义函数 下方，使用连续的三对引号（上图所示），在引号内编写对函数的说明文字，然后在 函数调用 位置使用Ctrl+Q 可以查看函数的说明信息

18.3 函数传递参数

函数参数：增加函数的通用性，针对相同的数据处理逻辑，能够使用更多的数据，在函数内部，把参数当作变量使用，函数调用时，按照函数定义的“参数顺序”，把希望在函数内部处理的数据，通过参数传递

固定参数

def sum_num():num1 = 10         #写入两个固定值num2 = 20result = num1 + num2print('%d + %d = %d' % (num1, num2, result))
sum_num()
print(type(sum_num()))

如果才行随意传入两个值，进行计算？？这就用到了函数参数。

传递参数

def sum_num_s(num1, num2):       #定义两个参数 num1和num2result = num1 + num2print('%d + %d = %d' % (num1,num2,result))
sum_num_s(5, 6)                 #在此处传入两个参数5和6

18.4 函数的返回值

返回值：一个函数执行后，告诉调用者一个结果，使用return关键字进行返回结果，也可以使用变量来接收函数的返回结果

def sum_num(num1, num2):return num1 + num2print('这是一个测试') #return后面的代码不会被执行，因此结果没有该信息#我们可以使用一个变量进行函数的返回值的接收
result  = sum_num(20, 30)
print('计算结果：%d' % result)#输出
计算结果：50

注意：在函数中使用return，return后面的代码就不会被执行的。return代表当前函数已经执行完毕，若是要打印两个值，需要传递两个变量

def sum_num(num1, num2):return num1, num2print('这是一个测试')   #return后面的代码不会被执行，因此结果没有该信息#我们可以使用一个变量进行函数的返回值的接收
result = sum_num(20, 30)
print(f'输出的值分别为:{result}')#输出
(10, 20)

18.5 函数嵌套

嵌套调用：一个函数里面又被另外一个函数调用，就是函数嵌套
如果函数 test2 中，调用了另外一个函数 test1

那么执行调用时，先执行完test1，再回到test2中继续执行后续代码

def test1():print('*' * 50)print('当前函数名称：test1')print('*' * 50)def test2():print('-' * 50)print('当前函数名称：test2')test1()                     #在此调用函数test1print('-' * 50)test2()                         #调用test2#输出
--------------------------------------------------
当前函数名称：test2
**************************************************
当前函数名称：test1
**************************************************
--------------------------------------------------
Process finished with exit code 0

案例

def print_line_1(char):         #用参数定义分割线print(char * 50)            #传入分割线和次数
print_line_1('_')             #将分割线定义为 - 符号，并调用

def print_line_2(char, num):    #用参数定义分割线和次数print(char * num)
print_line_2('%',10)          #将分割线定义为 % 符号和次数，并调用

def print_line_3(char, num): #先定义一个函数，和参数print(char * num)def print_line_4(char, num):    #再定义函数和参数row = 0                       #定义行数初始为0行while row < 5:             #条件print_line_3(char, num)row += 1                #+1 进入循环，如果没有这个即使死循环
print_line_4('*', 30)         #传入参数给4和3#输出
__________________________________________________
%%%%%%%%%%
******************************
******************************
******************************
******************************
******************************Process finished with exit code 0

18.6 模块中的函数

模块是Python程序架构的一个核心概念

模块类似工具包，若要使用这个工具，需要使用 import 进行导入这个模块

每个以扩展名.py结尾的Python源代码都是一个模块

在模块中定义的全局变量、函数都是模块能够提供给外界直接使用的工具

体验自建模块
1）定义一个<python自建模块1.py> ，内容如下：(模块一定是py结尾，不然import识别不到)

name = "小明"

2）定义一个<python自建模块2.py> ，内容如下：

def test(num1, num2):print('%d + %d = %d' % (num1, num2, num1 + num2))

3）定义一个<python自建模块测试> ，内容如下：

import python自建模块1       #由于python自建模块与当然脚本同一个目录，可以直接通过名称调用
import python自建模块1print(python自建模块1.name)python自建模块2.test(2, 3)#输出
C:\Users\qingchen\AppData\Local\Programs\Python\Python39\python.exe C:/python_project/Python自建模块测试.py
小明
2 + 3 = 5Process finished with exit code 0

18.7 函数中的位置参数（含不定长参数）

- 位置参数

def user_info(name, age, gender):print(f'你的名字：{name},你的年龄{age}, 你的性别是{gender}')user_info('细雨', 20, '男')
user_info('细雨', '男', 20)        #不会报错，但是位置参数不能调换位置
user_info('细雨', 20)            #报错，位置参数必须数量与函数中一致

- 不定长位置参数=包裹位置传递，对参数个数没有限制，返回是元组

def user_info(*args):print(args)user_info('TOM')
user_info('TOM', 18)#输出
('TOM',)
('TOM', 18)

18.8 函数中的关键字参数（含不定长参数）

- 关键字参数

def user_info(name, age, gender):print(f'你的名字：{name},你的年龄{age}, 你的性别是{gender}')user_info('细雨', age=20, gender='男')
user_info('细雨', gender='男', age=20)   #不会报错，如果函数调用时，如果有位置参数，位置参数（name）一定要在关键字参数的前面，关键字参数之间不存在先后顺序

- 不定长关键字参数=包裹关键字传递，返回是字典

def user_info(**kwargs):print(kwargs)user_info(name = 'TOM', age=20)#输出
{'name': 'TOM', 'age': 20}

无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程

18.9 函数的运用案例 - 学员管理系统

def info_print():print('1.添加学员')print('2.删除学员')print('3.修改学员')print('4.查询学员')print('5.显示所有学员')print('6.退出系统')info_print()
info = []def add_info():"""添加学员函数"""#接收用户输入信息new_id = int(input('请输入学员学号:'))new_name = str(input('请输入学员姓名:'))new_tel = int(input('请输入学员手机号:'))global infofor i in info:if new_name == i['name']:print('该学员已经存在')returninfo_dict = {}info_dict['id'] = new_idinfo_dict['name'] = new_nameinfo_dict['tel'] = new_telinfo.append(info_dict)print(info)def del_info():print(f'目前学员信息如下:{info},请按照以下提示进行操作')del_name = input('请输入要删除的学员姓名：')#global info#判断学员是否存在for i in info:if del_name == i['name']:info.remove(i)print(f'学员{del_name}已删除')breakelse:print('该学员不存在')def modify_info():"""修改学员信息"""modify_name = input('请输入修改的学员姓名:')global infofor i in info:if modify_name == i['name']:i['tel'] = input('请输入该学员新的手机号码:')breakelse:print('该学员不存在')
def search_info():"""查询学员信息"""search_name = input('请输入要查询的学员姓名:')global infofor i in info:if search_name == i['name']:print('查找结果如下：')print(f"该学员学号为:{i['id']},姓名是:{i['name']}，手机号为:{i['tel']}")breakelse:print('该学员不存在')def print_all():"""显示所有学员信息"""print('学号\t姓名\t手机号')for i in info:print(f"{i['id']}\t{i['name']}\t{i['tel']}")def exit_sys():sure = input('确定要退出系统吗？ 请输入yes or no:')if sure == 'yes':print('系统已退出！！')elif sure == 'no':info_print()user_num = int(input('请输入功能序号：'))
#循环显示
while True:user_num = int(input('请输入功能序号：'))if user_num == 1:print('添加学员，请按照以下说明进行填写！！')# 调用添加函数add_info()elif user_num == 2:print('删除学员信息')del_info()elif user_num == 3:print('修改学员信息')modify_info()elif user_num == 4:print('查询')search_info()elif user_num == 5:print('显示所有学员')print_all()elif user_num == 6:sure = input('确定要退出系统吗？ 请输入yes or no:')if sure == 'yes':print('系统已退出！！')breakelif sure == 'no':info_print()else :print('输入的序号有误,请输入1-6')

19. 面向对象

面向对象是一种非常流行的*编程范式*

19.1 类和对象

#class Student:                      #用class定义类，Student是类名
class Student():  #同方法 class Student:   此时定义类名使用大驼峰命名法# 如果函数在类中，那么就被称为类方法def ball(self, course_name):    #ball类方法print('学生正在操场打：%s.' % course_name)def read(self, book):           #read也是一个方法print(f'学生们正在看：{book}.')stu01 = Student()           #定义类Student的对象为stu01
print(stu01)                #直接打印对象的话，会输出的值为实例在内存中的地址（16进制）
print(id(stu01))            #打印当然对象的id
print(hex(id(stu01)))       #将id转为16进制 ，用hex公共方法#使用对象调用方法，打印结果
stu01.read('小说')#想要去调用当前类中的方法，先要对类进行实例化，实例化方法就是对类Student()
Student().ball('basketbook 篮球')#输出
C:\Users\qingchen\AppData\Local\Programs\Python\Python39\python.exe "C:/python_project/面向对象 - 类和对象.py"
<__main__.Student object at 0x000001F076BE3FD0>
2132295958480
0x1f076be3fd0
学生们正在看：小说.
学生正在操场打：basketbook 篮球.Process finished with exit code 0

注意：

用class定义一个类（比如Student），类里面的函数成为类方法

通过类声明一个对象（stu01）

通过对象.方法去调用类中的方法

通过类().方法去调用类中的方法 //类（）就是对类进行实例化，之后才能调用

19.2 初始化方法

之前我们创建的对象只有行为，没有属性，如果要给对象定义属性，可以使用一个名为__init__的方法。

在我们调用Student类的构造器创建对象时，首先会在内存中获得保存学生对象所需的内存空间，然后通过自动执行__init__方法，完成对内存的初始化，也就是把数据放到内存空间中，所以我们可以通过给Student类添加__init__方法的方式为学生对象指定属性，同时完成对属性赋初始值的操作，因此，__init__方法也被称为初始化方法。

class Student:#初始化方法 给当前对象创建属性def __init__(self, name, age):#给当前类添加属性self.name = nameself.age = agedef ball(self, course_name):  # ball 为类方法print('学生%s正在操场打%s' % (self.name, course_name))     #普通输出，不用f格式化print(f'学生{self.name}正在操场打{course_name}')           #f格式化输出def read(self, book):  # read也是一个方法print(f'学生{self.name}正在看{book}.')#实例化类
stu01 = Student('熙雨',22)
stu01.ball('篮球')stu02 = Student('小野',21)
stu02.read('挪威的森林')#输出
学生熙雨正在操场打篮球
学生熙雨正在操场打篮球
学生小野正在看挪威的森林.Process finished with exit code 0

19.3 打印对象

打印对象的结果时一串内存地址，但是我们不想看到这些，做到自定义就可以用到repr魔法方法

class Student:#初始化方法 给当前对象创建属性def __init__(self, name, age):#给当前类添加属性self.name = nameself.age = agedef __repr__(self):return (f'这个地方如果不用repr魔法方法的话,默认打印时内存地址')def ball(self, course_name):  # ball 为类方法
#        print('学生%s正在操场打%s' % (self.name, course_name))     #普通输出，不用f格式化print(f'学生{self.name}正在操场打{course_name}')           #f格式化输出def read(self, book):  # read也是一个方法print(f'学生{self.name}正在看{book}.')#实例化类
stu01 = Student('熙雨',22)
stu01.ball('篮球')
print(stu01)stu02 = Student('小野',21)
stu02.read('挪威的森林')#输出
学生熙雨正在操场打篮球
这个地方如果不用repr魔法方法的话,默认打印时内存地址
学生小野正在看挪威的森林.

19.4 可见性与属性装饰器

class Student():#初始化方法 给当前对象创建属性def __init__(self, name, age):#给当前类添加属性self.__name = nameself.__age = agedef __repr__(self):return (f'这个地方如果不用repr魔法方法的话,默认打印时内存地址')def ball(self, course_name):  # ball 为类方法
#        print('学生%s正在操场打%s' % (self.name, course_name))     #普通输出，不用f格式化print(f'学生{self.__name}正在操场打{course_name}')           #f格式化输出def read(self, book):  # read也是一个方法print(f'学生{self.__name}正在看{book}.')#实例化类
stu01 = Student('熙雨',22)
stu01.ball('篮球')stu02 = Student('小野',21)
stu02.read('挪威的森林')print(stu01.name)
#print(stu01._Student__name)#输出
学生熙雨正在操场打篮球
学生小野正在看挪威的森林.
Traceback (most recent call last):File "C:\python_project\面向对象-初始化方法.py", line 25, in <module>print(stu01.name)
AttributeError: 'Student' object has no attribute 'name'Process finished with exit code 1

说明：如果name加了__就会变成私有属性，只能在类内部被调用，因此print(stu01.name)会报错，不过严格意义上python并没有属性的私密性，也有方法可以调成功，将外部调用print(stu01.name) 改为print(stu01._Student__name)就可以解决

20. 面向对象-继承

单继承和多继承
面向对象三大特性

封装
继承
多态

20.1 面向对象 - 单继承

概念：子类拥有父类的所有方法和属性

1、不使用继承

'''
开发两个类动物类（特性：吃、喝、跑、睡）狗   （特性：吃、喝、跑、睡、汪汪叫）'''class Animal:def eat(self):print('吃')def drink(self):print('喝')def run(self):print('跑')def sleep(self):print('睡')class Dog:def eat(self):print('吃')def drink(self):print('喝')def run(self):print('跑')def bark(self):print('汪汪叫')#创建对象
wangcai = Animal()
wangcai.eat()
wangcai.sleep()#创建对象
wangcai = Dog()
wangcai.bark()#在不使用继承的情况下，会造成代码的重复

1、使用继承

class 类名(父类名):pass  #Python pass是空语句，是为了保持程序结构的完整性。pass不做任何事情，一般用做占位语句。

class Animal:def eat(self):print('吃')def drink(self):print('喝')def run(self):print('跑')def sleep(self):print('睡')class Dog(Animal):def bark(self):print('汪汪叫')class yuque(Dog):def fly(self):print('飞')#创建对象
wangcai = Dog()
wangcai.eat()
wangcai.bark()#使用继承的情况下，Dog类可以使用Animal类的方法，调整父类的化，子类的方法也会跟着改变

总结：

1、继承的说明
子类继承自父类，可以直接享受父类已经封装好的方法，不需要再次开发
子类中应该根据职责，封装子类特有的属性和方法
2、专业术语
Dog为Animal的子类（或者叫派生类）
Animal为Dog的父类

20.2 继承的传递性

C类从B类继承，B类又从A类继承
那么C类就具有B和A类的所有属性和方法

1）案例：动物类 --> 狗类 --> 哮天犬

class Animal:def eat(self):print('吃--')def drink(self):print('喝--')def run(self):print('跑--')def sleep(self):print('睡--')#创建狗类
class Dog(Animal):def bark(self):print('我是狗子，我会汪汪叫')
#创建一个哮天犬类
class XiaoTianQuan(Dog):def fly(self):print('我是哮天犬，我会飞')#创建一个哮天犬对象
xtq = XiaoTianQuan()
xtq.fly()
xtq.bark()#我们可不可以调用Animal中的方法？？？结果证明也是可以的，这就是继承的传递性
xtq.eat()
xtq.run()
#说明：哮天犬类继承狗类，够累继承动物类，那么哮天犬是狗类的子类，狗类是动物类的子类，那么哮天犬是动物类的子子类#输出
我是哮天犬，我会飞
我是狗子，我会汪汪叫
吃--
跑--

注意：在Animal的左侧也可以看到有两个子类

2）继承传递性的注意事项

class Animal:def eat(self):print('吃--')def drink(self):print('喝--')def run(self):print('跑--')def sleep(self):print('睡--')#创建狗类
class Dog(Animal):def bark(self):print('我是狗子，我会汪汪叫')
#创建一个哮天犬类
class XiaoTianQuan(Dog):def fly(self):print('我是哮天犬，我会飞')
class Cat(Animal):def catch(self):print('我是猫，我会抓老鼠')  #猫类继承自动物类，自身实现了一个方法（抓老鼠）#创建一个哮天犬对象，现在通过哮天犬对象能不能调用猫类方法？
xtq = XiaoTianQuan()
xtq.fly()
xtq.bark()
xtq.eat()xtq.catch()  #会报错，哮天犬调用猫类方法失败

注意：结果证明子类无法继承父类中其他子类中的方法

20.3 继承方法的重写

当父类的方法实现不能满足子类需求时，可以对方法进行重写（override），方法就是在子类中定义一个和父类中一个的方法，在子类进行调用时，会调用子类中的方法

class Animal:def eat(self):print('吃--')def drink(self):print('喝--')#创建狗类
class Dog(Animal):def bark(self):print('我是狗子，我会汪汪叫')
#创建一个哮天犬类
class XiaoTianQuan(Dog):def fly(self):print('我是哮天犬，我会飞')def bark(self):print('我是哮天犬，叫法肯定跟狗不一样')#创建一个哮天犬对象,修改哮天犬的继承Dog的bark方法，让它不是汪汪叫，因此需要重写父类方法
xtq = XiaoTianQuan()
xtq.bark()#输出
我是哮天犬，叫法肯定跟狗不一样
Process finished with exit code 0

20.4 面向对象 - 父类方法调用和拓展

如果子类向调用父类中的方法，需要使用到super()对象

class Animal:def eat(self):print('吃--')def drink(self):print('喝--')#创建狗类
class Dog(Animal):def bark(self):print('我是狗子，我会汪汪叫')
#创建一个哮天犬类
class XiaoTianQuan(Dog):def fly(self):print('我是哮天犬，我会飞')def bark(self):print('我是哮天犬，叫法肯定跟狗不一样')  #当子类的方法与父类的方法相同时，如果想调用父类的方法，就要使用super方法super().bark()  #super()也是一个对象Dog.bark(self)   #或者使用另外一种调用方式，python3中被保留，父类.方法（self）的方式print('这是一个测试...')
#输出
我是哮天犬，叫法肯定跟狗不一样
我是狗子，我会汪汪叫
我是狗子，我会汪汪叫
这是一个测试...

20.5 面向对象 - 父类的私有属性和私有方法

`子类对象 不能在子集的方法内部，直接访问父类的私有属性或者私有方法
子类对象 可以通过父类的 公有方法 间接访问到私有属性 或者私有方法

私有属性、方法时对象的隐私，不对外公开，外界以及子类都不能直接访问
私有属性、方法通常用于做一些内部的事情

案例一、子类无法调用父类的私有属性

class A:#创建类属性def __init__(self):  #初始化方法#创建公有属性self.num_1 = 100#创建私有属性self.__num_2 =200   #当前属性名称前面加上__就是私有属性#创建私有方法def __test(self):print(f'私有属性与公有属性的值：{self.num_1},{self.__num_2}')#创建的新类要继承自类A
class B(A):pass       #Python pass是空语句，是为了保持程序结构的完整性。pass不做任何事情，一般用做占位语句。#B具有父类A的所有属性
b = B()
print(b.num_1)      #打印公有属性，正常返回
print(b.__num_2)    #直接打印私有属性会报错#输出
AttributeError: 'B' object has no attribute '__num_2'
100

案例二、子类无法调用父类的私有方法

class A:#创建类属性def __init__(self):  #初始化方法#创建公有属性self.num_1 = 100#创建私有属性self.__num_2 =200   #当前属性名称前面加上__就是私有属性#创建私有方法def __test(self):print(f'私有属性与公有属性的值：{self.num_1},{self.__num_2}')#创建的新类要继承自类A
class B(A):#   pass       #Python pass是空语句，是为了保持程序结构的完整性。pass不做任何事情，一般用做占位语句。def demo(self):#父类方法super.__test()#B调用父类中的私有方法b.demo()           #不允许子类直接调用父类的私有方法#输出IndentationError: unindent does not match any outer indentation level

案例三、子类间接使用父类的私有属性和私有方法

说明：子类可以通过父类中的公有方法间接访问到私有属性和私有方法

class A:#创建类属性def __init__(self):  #初始化方法#创建公有属性self.num_1 = 100#创建私有属性self.__num_2 =200   #当前属性名称前面加上__就是私有属性#创建私有方法def __test(self):print(f'私有属性与公有属性的值：{self.num_1},{self.__num_2}')def test(self):print(f'父类中的公有方法输出私有属性：{self.__num_2}')#在公有方法中调用私有方法self.__test()                 #可调用成功#创建的新类要继承自类A
class B(A):#公有方法def demo(self):#1.在子类方法中访问父类的公有属性print(f'子类方法输出父类中的公有属性：{self.num_1}')  #可以正常输出公有属性#2.在子类中调用父类的公有方法输出私有属性self.test()
b = B()
b.demo()#总结：子类可以通过父类中的公有方法间接访问到私有属性和私有方法
#输出
父类中的公有方法输出私有属性：200
私有属性与公有属性的值：100,200

20.6 面向对象 - 多继承

子类可以拥有多个父类，并且具有所有父类的属性和方法

class 子类名(父类名1，父类名2...)pass

案例一、子类调用多个父类方法

class A():def test(self):print('test方法')class B():def demo(self):print('demo方法')class C(A, B):passc = C()
c.test()
c.demo()#总结：在python中，面向对象是支持多个类进行继承的，子类同时具体多个父类的所有方法和属性
#输出
test方法
demo方法

多继承的使用注意事项
注意：如果在多继承情况下，父类中的方法有重名，尽量避免使用多继承，结果会按照调用顺序进行继承

class A():def test(self):print('A --- test方法')def demo(self):print('A --- demo方法')class B():def test(self):print('B --- test方法')def demo(self):print('B --- demo方法')class C(B, A):  #注意：调用的顺序和继承的顺序一致passc = C()
c.test()
c.demo()
#输出
B --- test方法
B --- demo方法

20.7 面向对象 - 新式类、旧式类和__mro搜索顺序

object 是python为所有对象提供的基类，提供一些内置的属性和方法，可以使用dir()函数查看

新式类：以object为基类的类，推荐使用（python3中默认使用object作为类的基类，而python2中需要手动指定）
经典类：不以object为基类的类，不推荐使用

class 类名(object):pass

20.8 面向对象 - 多态

我们在调用子类中的同名方法时，输出的值不一样，包括继承和重写

案例多态

class A():def work(self):print('人类需要工作')
class B(A):def work(self):print('程序员在工作 -- 代码')
class C(A):def work(self):print('设计师在工作 -- 图纸')b = B()
c = C()
b.work()
c.work()
#输出
程序员在工作 -- 代码
设计师在工作 -- 图纸

案例多态演示

class Dog:#定义类属性def __init__(self, name):self.name = name#定义类的方法def game(self):print('%s 蹦蹦跳跳的玩耍...' % self.name)class XiaoTianQuan(Dog):'''子类继承父类的时候，具有父类所有的属性和方法'''#定义类方法def game(self):print(f'{self.name}飞到天上去玩耍...')class Person():#定义类属性def __init__(self, name):self.name = namedef game_with_dog(self, dog):#让狗玩耍dog.game()#让狗与人一起玩耍print(f'{dog.name}是一只狗')print('%s 和%s 快乐的玩耍' % (self.name, dog.name))#创建一个普通狗对象
#wangcai = Dog('旺财')
wangcai = XiaoTianQuan('飞天旺财')#创建人的对象
xiaoming = Person('小明')
xiaoming.game_with_dog(wangcai)
#输出
飞天旺财飞到天上去玩耍...
飞天旺财是一只狗
小明 和飞天旺财 快乐的玩耍

21. 模块管理

21.1 模块查看

查看已安装模块，Windows或Linux控制台下查看模块

pip list #该命令查看的是Python安装的第三方模块。pip freeze   #该命令属于老版本的Python了。pydoc modules #该命令查看的是所有的模块，包括內建模块，截图类似下面的help。

查看已安装模块，Python交互解释器查看模块

help('modules')        #该命令查看的是所有的模块，包括內建模块。

查看已安装模块，导入sys模块查看

1 >>> import sys
2 >>> sys.modules.keys()       #这个方法查看的更加详细，只是不太便于观看。

21.2 模块安装

以pymysql为例

pip install pymysql

22 python常用模块使用

22.1 os模块

os 模块提供了丰富的方法用来处理文件和目录

#导入os模块
import osos.rename('1.txt', '2.txt')    #对文件或者文件夹重命名
os.remove('2.txt')            #删除文件
os.mkdir('xiyu')          #创建文件夹
os.rmdir('xiyu')          #删除文件夹
print(os.getcwd('xiyu'))  #获取当前目录
print(os.chdir(目录)) #改变路径
print(os.listdir())     #获取目录列表os.getcwd()      #获取路径
os.chdir()      #切换工作目录到指定的路径下，如果成功，返回True，操作失败，返回False
os.makedirs(name, mode=511, exist_ok=False)       #递归地创建目录并设置访问权限，类似于linux中的 mkdir -p。默认的访问权限为 511
os.chmod(path, mode)        #更改目录或文件的访问权限。os.open(file, flags, mode=0o777)     #打开一个文件，并设置打开选项与访问权限，返回文件对应的描述符。默认的访问权限为777。os.system(command)            #在子shell中执行命令，并返回命令执行的退出状态码
os.symlink(src, dst)        #为文件 src 创建软链接 dstprint(os.environ)     #返回包含当前系统所有环境变量的一个mapping对象

22.2 sys模块

22.3 time模块

print(time.clock())
print(time.time())
print(time.localtime())
print(time.strftime("%Y-%m-%d %X",time.localtime()))#输出
0.02
1648893130.4114902
time.struct_time(tm_year=2022, tm_mon=4, tm_mday=2, tm_hour=17, tm_min=52, tm_sec=10, tm_wday=5, tm_yday=92, tm_isdst=0)
2022-04-02 17:52:10

22.3 pymysql模块

详见《24.使用python提取mysql数据库信息》

24. 使用python提取mysql数据库信息

#!/usr/bin/python
# -*- coding: UTF-8 -*-import pymysqldb = pymysql.connect(host = '47.98.187.230',port = 3306, user = 'root',passwd = 'Admin123****',db = 'myemployees')
#使用 cursor() 方法创建一个游标对象 cursor
cursor = db.cursor()# 使用 execute()  方法执行 SQL 查询
#cursor.execute('select * from jobs limit 10')
cursor.execute("insert into jobs values ('AC_ACCOUNN', 'Public Accountant', 12000, 20000);")  插入数据，若是insert内部使用单引号，外部必须使用双引号
cursor.execute('select * from jobs limit 10')
#使用 fetchone() 方法获取单条数据
date = cursor.fetchall()# 使用 execute()  方法执行 SQL 查询
cursor.execute('SELECT VERSION()')
#使用 fetchone() 方法获取版本号
ver = cursor.fetchall()print(f'数据库返回记录为：{date}')
print(f'数据库版本为：{ver}')#关闭数据库
cursor.close()
db.close()