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

注意：

  1. 用class定义一个类（比如Student），类里面的函数成为类方法
  2. 通过类声明一个对象（stu01）
  3. 通过对象.方法去调用类中的方法
  4. 通过类().方法去调用类中的方法 //类（）就是对类进行实例化，之后才能调用
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()
# python
Logo
CSDN学习社区

CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！

更多推荐

cover

用 OpenAI Assistants 做大模型应用开发

avatar CSDN学习社区
cover

1 小时解读鸿蒙 10 大热点问题

avatar CSDN学习社区
cover

1 小时解读鸿蒙 10 大热点问题

avatar CSDN学习社区