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 * weight
print(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('年龄太合适,回家去吧')
or
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 += 1
print('这是一个死循环:%d' % i)
自然计数法:从1开始
程序计数法:从0开始
案例
计算0-100所有数字的和
i = 0
result = 0
while i<= 100:
print(i)
result += i
i += 1
print('所有数字的和为: %d ' % result)
案例
计算0-100所有偶数数字的和
i = 0
result = 0
while i<= 100:
print(i)
result += i
i += 2
print('所有偶数的和为: %d ' % result)
或者
i = 1
result = 0
while i <= 100:
if i % 2 ==0:
print(i)
result += i
i += 1
else:
i += 1
print('所有偶数的和为: %d ' % result)
while循环嵌套
while 条件1:
条件满足时,做的事情1
条件满足时,做的事情1
条件满足时,做的事情1
while 条件2:
条件满足时,做的事情1
条件满足时,做的事情1
条件满足时,做的事情1
处理条件2
处理条件1
9*9乘法表
y = 1 #y 代表行数,最大9行
while y <= 9:
x = 1
while x <= y:
print("%d * %d = %d" %(x, y, x*y),end="\t")
x += 1
print("")
y += 1
11. Python - 终止循环(break和continue)
break
i = 0
while i <= 10: #当i == 5的时候直接中断,并且不打印,所以只打印到4
if i == 5:
break
print(i)
i += 1
print("over")
continue
i = 0
while i <= 10:
if i == 5: #当i等于5时,它会中断(意思就是这次不打印了),但是由于下面的continue,它会继续,直到i<=10 就会整体中断
i += 1
continue #只作用域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出现的位置,所以索引坐标为4
print(s.find('o', 5)) #从前向后查找 从5开始查找o出现的位置,索引坐标为7
print(s.rfind('o')) #从后向前查找 首次o出现的位置,所以索引坐标为12
性质判断
str_test = "hello world!"
print(str_test.startswith('He')) #判断开始否是He开头,不是则返回False
print(str_test.startswith('hel')) #判断开始否是hel开头,是则返回True
print(str_test.endswith('!')) #判断末尾否是!结尾,是则返回True
字母、数字构成判断
str_test_01 = "abcd1234"
print(str_test_01.isdigit()) #判读是否纯数字,返回True和False
print(str_test_01.isalnum()) #判读是否是数字和字母构成,返回True和False
str_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
0000000123
123
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 = 20
result = num1 + num2
print('%d + %d = %d' % (num1, num2, result))
sum_num()
print(type(sum_num()))
如果才行随意传入两个值,进行计算??这就用到了函数参数。
- 传递参数
def sum_num_s(num1, num2): #定义两个参数 num1和num2
result = num1 + num2
print('%d + %d = %d' % (num1,num2,result))
sum_num_s(5, 6) #在此处传入两个参数5和6
18.4 函数的返回值
返回值:一个函数执行后,告诉调用者一个结果,使用return关键字进行返回结果,也可以使用变量来接收函数的返回结果
def sum_num(num1, num2):
return num1 + num2
print('这是一个测试') #return后面的代码不会被执行,因此结果没有该信息
#我们可以使用一个变量进行函数的返回值的接收
result = sum_num(20, 30)
print('计算结果:%d' % result)
#输出
计算结果:50
注意:在函数中使用return,return后面的代码就不会被执行的。return代表当前函数已经执行完毕,若是要打印两个值,需要传递两个变量
def sum_num(num1, num2):
return num1, num2
print('这是一个测试') #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() #在此调用函数test1
print('-' * 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自建模块1
print(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 = 5
Process 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 info
for i in info:
if new_name == i['name']:
print('该学员已经存在')
return
info_dict = {}
info_dict['id'] = new_id
info_dict['name'] = new_name
info_dict['tel'] = new_tel
info.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}已删除')
break
else:
print('该学员不存在')
def modify_info():
"""修改学员信息"""
modify_name = input('请输入修改的学员姓名:')
global info
for i in info:
if modify_name == i['name']:
i['tel'] = input('请输入该学员新的手机号码:')
break
else:
print('该学员不存在')
def search_info():
"""查询学员信息"""
search_name = input('请输入要查询的学员姓名:')
global info
for i in info:
if search_name == i['name']:
print('查找结果如下:')
print(f"该学员学号为:{i['id']},姓名是:{i['name']},手机号为:{i['tel']}")
break
else:
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('系统已退出!!')
break
elif 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 = name
self.age = age
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('挪威的森林')
#输出
学生熙雨正在操场打篮球
学生熙雨正在操场打篮球
学生小野正在看挪威的森林.
Process finished with exit code 0
19.3 打印对象
打印对象的结果时一串内存地址,但是我们不想看到这些,做到自定义就可以用到repr魔法方法
class Student:
#初始化方法 给当前对象创建属性
def __init__(self, name, age):
#给当前类添加属性
self.name = name
self.age = age
def __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 = name
self.__age = age
def __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):
pass
c = 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): #注意:调用的顺序和继承的顺序一致
pass
c = 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 = name
def 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 os
os.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 创建软链接 dst
print(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 pymysql
db = 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()