Python学习笔记（更新中）

第一节

#输出
print("你好，世界",end="\t") #\t水平制表符
print("你好","世界",sep="...")  #两个字符串之间用"..."隔开
print(r"C:\abd/def")    #r
x = 3
y = 5
x,y = y,x
print(x)
print(y)
# name = input("请输入你的姓名：")
# age = int(input("请输入你的年龄："))    #字符串转换成整型
# print(f'你的名字是{name},你的年龄是{age}')
# print(f'你的名字是{name},你的年龄是{age+1}')
print("1"+"2")
print(int("1")+int("2"))
print(type(5))
print(type(10//3))
print(5//2)
print(type(5/2))
a=b=3
print(a==b)

running

你好，世界	你好...世界
C:\abd/def
5
3
12
3
<class 'int'>
<class 'int'>
2
<class 'float'>
True

字符串

#‘，“，’‘’，都可以表示字符串，三引号可以换行
print('I\'m a bigtom')  #'\'转义字符
#find() 查找字符
a = "只要地球不爆炸，我相信总有一天，全世界都说中国话！中国会成为全世界的风向标！"
print(a.find("中国"))
print(a.find("中国",24,32))
print(a.find("美国"))     #查找不到返回-1
print(a.rfind("中国"))    #从右向左查找
#index()和find()相似，不同之处在于index在没有找到字符串时会报错,下面的程序将不再执行
#count() 计算字符出现次数
print(a.count("中国"))
print(a.count("中国",12,34))
#replace() 替换字符
print(a.replace("中国","祖国"))     #replace("旧字符串","新字符串")
print(a.replace("中国","祖国",2))   #替换两个
#split() 分割
b = "你好，中国！* 你好，世界！* 你好，宇宙！*"
print(b.split("*"))
print(b.split("*",2))   #分割两次
#jion() 合并
c = ['中','国','最','强']
print('_'.join(c))
#变量名.startswith(子串,开始下标位置,结束下表位置)
#变量名.endswith(子串,开始下标位置,结束下表位置)
d = "abcdefghi"
print(d.startswith("ab"))  #位置省略则按照全部位置
print(d.startswith("ab",3,6))

running

I'm a bigtom
21
25
-1
25
2
2
只要地球不爆炸，我相信总有一天，全世界都说祖国话！祖国会成为全世界的风向标！
只要地球不爆炸，我相信总有一天，全世界都说祖国话！祖国会成为全世界的风向标！
['你好，中国！', ' 你好，世界！', ' 你好，宇宙！', '']
['你好，中国！', ' 你好，世界！', ' 你好，宇宙！*']
中_国_最_强
True
False

列表

变量名 = ['唐僧','猪八戒','孙悟空','沙僧']
print(f'{变量名[2]}，我叫一声你敢答应ლ(′◉❥◉｀ლ)')
#列表常用操作---增--删--改--查
#   切片
print(变量名[1:3:1])   #   语法：序列[开始下标位置:结束下表位置:步长]
#   index
print(变量名.index('孙悟空'))
#   count
print(变量名.count('沙僧'))
#   len()返回列表长度
print(len(变量名))

running

孙悟空，我叫一声你敢答应ლ(′◉❥◉｀ლ)
['猪八戒', '孙悟空']
2
1
4

列表操作--增

1. 变量名.append（数据） 列表结尾追加数据【追加单个数据】！！！注意“不能一次追加多个数据，增加多个数据是将整个序列追加到列表
2. 变量名.extend（数据） 列表结尾追加数据【追加多个数据】
3. 变量名.insert（数据） 在指定位置新增数据

变量名 = ['唐僧','猪八戒','孙悟空','沙僧']
变量名.append('白龙马')
print(变量名)
变量名.extend(['如来佛祖','牛魔王','铁扇公主'])
print(变量名)
变量名.insert(7,'红孩儿')
print(变量名)  #在指定位置新增数据

running

['唐僧', '猪八戒', '孙悟空', '沙僧', '白龙马']
['唐僧', '猪八戒', '孙悟空', '沙僧', '白龙马', '如来佛祖', '牛魔王', '铁扇公主']
['唐僧', '猪八戒', '孙悟空', '沙僧', '白龙马', '如来佛祖', '牛魔王', '红孩儿', '铁扇公主']

列表操作--删

变量名 = ['唐僧','猪八戒','孙悟空','沙僧']
del 变量名[1]
print(变量名)
变量名.pop()   #删除最后一个数据，并返回该数据
print(变量名)
a = [1,2,3,4,5,6]
a.remove(2)
print(a)
a.clear()   #清空列表，创建空列表 b = []
print(a)

running

['唐僧', '孙悟空', '沙僧']
['唐僧', '孙悟空']
[1, 3, 4, 5, 6]
[]

列表操作--改

a = [6,5,4,3,2,1,0]
a.sort()    #从小到大排序
print(a)
a.reverse() #倒序
print(a)
b = [1,3,5,9,6,2]
c = [1,3,5,9,6,2]
b.sort(reverse=False)   #升序
c.sort(reverse=True)    #降序
print(b)
print(c)
#列表复制
d = a.copy()
print(a)

runnning

[0, 1, 2, 3, 4, 5, 6]
[6, 5, 4, 3, 2, 1, 0]
[1, 2, 3, 5, 6, 9]
[9, 6, 5, 3, 2, 1]
[6, 5, 4, 3, 2, 1, 0]

列表操作--查(列表嵌套)

a = ['唐僧', '猪八戒', '孙悟空', '沙僧', '白龙马']
for 临时变量 in a:
    print(临时变量)
#   列表嵌套
aa = [['唐僧', '猪八戒', '孙悟空', '沙僧', '白龙马'], ['如来佛祖', '观音菩萨'],['牛魔王', '红孩儿', '铁扇公主']]
#   如何找到牛魔王
print(aa[2][0])

running

唐僧
猪八戒
孙悟空
沙僧
白龙马
牛魔王

元组

一个元组可以存储多个数据，且里面的数据不能被修改。

• 变量名 = ('孙悟空','唐僧','猪八戒','沙和尚') 多个数据
• 变量名 = ('孙悟空',) 单个数据(‘,’不要忘写)
• 变量名 = (520) 这是一个整型
• 变量名 = ('孙悟空') 这是一个字符型
• 变量名 = （） 定义一个空元祖

a = ('孙悟空','猪八戒','唐僧','沙僧')
print(a[1])
print(a[1:3])   #切片--“左闭右开”--
print(a.index('猪八戒'))   #元组tuple没有find(),也没有清空操作
print(a.count('沙僧'))
print(len(a))
#   把最后一个'沙僧'删除，把唐僧加到孙悟空和猪八戒之间
a = a[0:1]+('唐僧',)+a[1:2]   #简写--- a = a[:1]+('唐僧',)+a[1:2]
print(a)

runnning

猪八戒
('猪八戒', '唐僧')
1
1
4
('孙悟空', '唐僧', '猪八戒')

字符串、列表、元组总结

1. 都可以通过下标（索引）查询数据，下标从0开始，下标支持负数
2. 都可以通过切片的方法得到一个范围内的数据

我们将字符串、列表、元组统称为序列！

3个数值类型转换

#三种类型转换
print(int(1.5))
print(float(2))
print(str(520))

running

1
2.0
520

2个类型转换

a = [1,2,3,4,5,6]   #列表
b = (1,2,3,4,5,7)   #元组
print(tuple(a))
print(list(b))

running

(1, 2, 3, 4, 5, 6)
[1, 2, 3, 4, 5, 7]

字典与集合

字典--增--删--改--查

a = {"唐僧":1,"孙悟空":2,"猪八戒":3,"沙僧":4}
a["白龙马"]=5  #字典中存在该数据则直接修改，若无此数据则新增该数据
print(a)
a["沙僧"]=5
print(a)
print(a["孙悟空"]) #若存在则返回键值，否则报错
#删除
del a["孙悟空"]  #删除指定的键值对
print(a)
a.clear()
print(a)

running

{'唐僧': 1, '孙悟空': 2, '猪八戒': 3, '沙僧': 4, '白龙马': 5}
{'唐僧': 1, '孙悟空': 2, '猪八戒': 3, '沙僧': 5, '白龙马': 5}
2
{'唐僧': 1, '猪八戒': 3, '沙僧': 5, '白龙马': 5}
{}

字典的查询方法

• get() 语法：字典序列名.get(键名,a) 若查询到键名则返回其值，否则返回a，若没有写a，则返回默认值
• values() 语法：字典序列名.values() 返回字典中所有的值
• items() 语法：字典序列名.items() 可迭代对象（里面的数据是元祖），迭代就是重读反馈的过程

for 循环、公共操作与推导式

公共方法

函数	描述
len()	计算容器中的元素个数
del或del()	删除
max()	返回容器中元素最大值
min()	返回容器中元素最小值
range(beg,end,step)	生成从beg到end的数字，步长为step，供for循环使用
enumerate()	函数用于将一个可比遍历的数据对象（如列表、元组或字符串组合成为一个索引序列，同时列出数据和数据下标，一般用在for循环当中。

enumerate语法：enumerate(可遍历的对象，start = 0)

• 注意：start参数用来设置遍历数据的下标的起始位置，默认值为0

点击查看代码

a = {"唐僧":1,"孙悟空":2,"猪八戒":3,"沙僧":4}
for i in enumerate(a):
    print(i)
for i in a:
    print(i)
for i,j in enumerate(a,1):#从1开始 i:下标 j:数据
    print(f'对应的下标是：{i}\t对应的数据是：{j}')
b = [i for i in range(0,11,2) if i%2 == 0]#数据满足后边if语句内容才存放到数组中
print(b)

(0, '唐僧')
(1, '孙悟空')
(2, '猪八戒')
(3, '沙僧')
唐僧
孙悟空
猪八戒
沙僧
对应的下标是：1	对应的数据是：唐僧
对应的下标是：2	对应的数据是：孙悟空
对应的下标是：3	对应的数据是：猪八戒
对应的下标是：4	对应的数据是：沙僧
[0, 2, 4, 6, 8, 10]

字典推导式

作用：快速合并列表为字典或提取字典中目标数据
将两个列表快速合并成一个字典：

列表1 = ['华为','苹果','三星','小米']
列表2 = [520,13,14,520]
字典名 = {列表1[变量名]:列表2[变量名] for 变量名 in range(len(列表1))}

提取字典中的目标数据：

字典名 = {'华为':520,'小米':520,'苹果':13,'三星':14}
#提取销售数量大于100台的字典数据
新字典名 = {键：值 for 键，值 in 字典名.items() if 值>=100}
    print(新字典名）

• items()语法：字典序列名.items()
  • 可迭代对象（里面的数据是元组），迭代就是重复反馈过程

点击查看代码

a = ['华为','小米','三星','苹果']
b = [520,520,13,24]
c = {a[i]:b[i] for i in range(len(a))}
print(c)
d = {i:j for i,j in c.items() if j>100}
print(d)

running

{'华为': 520, '小米': 520, '三星': 13, '苹果': 24}
{'华为': 520, '小米': 520}

集合推导式

创建一个集合，数据为下方列表的3次方
列表名 = [2,3,4]
集合名 = {变量名**3 for 变量名 in 列表名} [8,27,4]

点击查看代码

f = [2,3,4]
g = [i ** 3 for i in f]
print(g)

running

[8, 27, 64]

函数

def Add(a,b):
    """加法函数"""
    i  = a + b
    print(i)
help(Add)
def MyPrint(姓名,性别,年龄):
    print(f'您的姓名是：{姓名}，您的性别是：{性别}，您的年龄是：{年龄}')
MyPrint('王五','女',19)
#关键字操作----
MyPrint(年龄 = '20',姓名 = '赵四',性别 = '男')
def name(*args):
    print(args)
name(20,10,30,50)#返回的是一个元组
#关键字可变参数
def name2(**kwargs):
    print(kwargs)
name2(长 = 20,宽 =  30,高 = 40)#返回的是一个字典
#变量
a = 13
def name3():
    global a  #声明a为全局变量（外部变量）
    a=1314  #在函数内部修改外部变量
    print(a)
name3()
#拆包
#元组拆包
def name4():
    return 1,2
a,b=name4()
print(a)
print(b)
#字典拆包
c = dict1 = {'name':'李昂','age':20}
def name5():
    return c
a,b = name5()
#打印键
print(a)
print(b)
#打印值
print(c[a])
print(c[b])

running

Help on function Add in module __main__:

Add(a, b)
    加法函数

您的姓名是：王五，您的性别是：女，您的年龄是：19
您的姓名是：赵四，您的性别是：男，您的年龄是：20
(20, 10, 30, 50)
{'长': 20, '宽': 30, '高': 40}
1314
1
2
name
age
李昂
20

函数式编程

• 孙金华老师：函数式编程是一种古老的编程模式，就是用函数（计算）来表示程序，用函数的组合来表达组合的思维方式。

#没有形参的
def name():
    return 520
print(name())
#lambda表达式
print((lambda :520)())
#有形参的
def a(a,b):
    return a+b
i = a(1,2)
print(i)
#lambda表达式
print((lambda a,b:a+b)(1,2))#a,b函数形参  a+b函数表达式   (1,2)函数实参
#默认参数
def name1(a,b,c=5):
    return a+b+c
print(name1(2,6))
#lambda表达式
print((lambda a,b,c=5:a+b+c)(2,6))
#可变位置参数
def name2(*args):
    print(args)
print(name2(1,2,3))#------返回的是元组
#lambda表达式
print((lambda *args:args)(1,2,3,4,5))
#可变关键字参数-----返回的是字典
def name3(**kwargs):
    print(kwargs)
print(name3(姓名='张三',年龄 = 30))
#lambda表达式
print((lambda **kwargs:kwargs)(姓名 = '王五',年龄 = 50))
#带条件语句的lambda语句
print((lambda a,b: a if a>b else b)(1,3))

running

520
520
3
3
13
13
(1, 2, 3)
None
(1, 2, 3, 4, 5)
{'姓名': '张三', '年龄': 30}
None
{'姓名': '王五', '年龄': 50}
3

列表中的字典数据排序

list1 = [{'name':'孙悟空','age':20},{'name':'猪八戒','age':21},{'name':'沙和尚','age':22}]
list1.sort(key=lambda x:x['age'],reverse=True)
print(list1)

running

[{'name': '沙和尚', 'age': 22}, {'name': '猪八戒', 'age': 21}, {'name': '孙悟空', 'age': 20}]

高阶函数

高阶函数:就是基于已有的函数定义新函数，以函数作为参数，返回也是函数

1.filter(函数名,可迭代对象)

作用：过度序列中不符合条件的元素

列表名 = [1,2,3,4,5,6,7,8,9,10]
def 函数名(x):
    return x%2 == 0
结果 = filter(函数名.列表名）
print(结果)  //打印的是对象地址
print(list(结果))

hint：

• filter有两个参数，第一个参数可以是函数，也可以是None.
• 当地一个参数是函数的时候，将第二个参数中每个元素进行计算。
• 当第一个元素是None的时候，直接将第二个参数中为True的值筛选出来。

点击查看代码

print(list(filter( lambda x:x%2,range(1,11))))
print(list(filter( lambda x:x%2==0,range(1,11))))

running

[1, 3, 5, 7, 9]
[2, 4, 6, 8, 10]

2.map(函数名,迭代对象)

作用：将可迭代对象的每一个元素作为函数的参数进行运算加工，直到可迭代序列的每个元素都加工完毕。

计算列表序列中个数字的二次方
列表名 = [1,2,3]
def 函数名(x):
    return x**2
结果 = map(函数名,列表名）
print(结果)//打印出来的是对象的地址
print(list(结果))//使用类型转换

点击查看代码

print(list(map( lambda x:x**2,range(1,5))))

running

[1, 4, 9, 16]

3.reduce(函数名(x,y),可迭代对象)

作用：函数中必须有两个参数，每次函数计算的结果继续和序列的下一个元素做累积计算。

计算 下面列表数据之和
import functools //导入模块
列表名 = [1,2,3,4]
def 函数名(a,b)；
    return a+b
结果 = functools.reduce(函数名,列表名)
print(结果)

点击查看代码

import functools
print(functools.reduce(lambda x,y:x+y,range(1,101)))

running

5050

文件和文件夹

1.文件打开

注意：不带路径的文件名默认去找该文件夹
文件对象 = open('文件名','访问模式')

访问模式	含义	解释
'r'	只读	如果文件不存在报错，不支持写
'w'	写入	如果文件不存在新建文件，写入时覆盖原有内容
'a'	追加	如果文件不存在新建文件，写入时在原有内容基础上追加新内容

访问模式可以省略，默认为'r'模式

访问模式特点：('b'二进制，'+'可读可写)

r,rb,r+,rb+:只要文件不存在都报错，文件指针（光标位置）放在文件开头
w,wb,w+,wb+:只要文件不存在就新建文件，文件指针在开头，用新内容覆盖原内容
a,ab,a+,ab+:只要文件不存在新建文件，文件指针在结尾

2.读写操作

文件操作.write('内容')
文件操作.read('num')

• num表示从文件中读取的数据的长度（单位是字节）【换行\n占一个字节】，省略就是表示读取所有数据

文件对象.readlines()需要赋值给一个变量

• 将整个文件内容一次性读取，并返回一个列表，原文件中的每一行为一个元素，例如['aaa\n','bbb\n','ccc']每一行都有换行自带\n，最后一行没有换行不带\n

文件对象.readline()需要赋值给一个变量

• 一次性读取一行内容，第一次调用读取第一行，第二次调用读取第二行，不带换行符\n

3.关闭

文件对象.close()

4.seek()移动文件指针

文件对象.seek(偏移量,起始位置)

• 起始位置：0开头，1当前位置，2文件结尾
• 偏移量：假设起始位置是开头，偏移量是5，那文件指针就在第六个字节上
• 偏移量和文件指针都为0时，可以只写一个0

例如：

文件对象 = open('文件名','r+')
文件对象.seek(2,0)
print(文件对象.rend())
文件对象.close

5.文件备份

1. 用户输入目标文件

• 文件名 = input('请输入您要备份的文件名：')

2. 规划备份文件的名字
   2.1. 提取后缀，找到名字中最左侧的点，名字和后缀分离点的位置 = 文件名.rfind('.')
   2.2. 组织新名字 = 原名字 + [备份] + 后缀

if 点的位置>0:
    后缀 = 文件名[点的位置：0]
else:
    print('文件名输入错误')
新名字 = 文件名[:点的位置] + '[备份]' + 后缀

6.文件和文件夹操作

1.os模块

操作文件和文件夹

import os #导入模块
os.函数名() #使用os模块相关内容

2.文件和文件夹重命名

os.rename('旧文件名','新文件名') #目标文件名可以写路径，否则默认当前文件夹下面
os.rename('旧文件夹','新文件夹')

3.删除文件

没有指定文件会报错
os.remove(目标文件夹)

4.创建文件夹

重复创建相同名字的文件夹会报错
os.mkdir(文件夹名字)

5.获取当前文件夹所在目录路径

os.getcwd()
例如：print(os.getcwd())

6.改变默认目录

os.chdir()
用于改变当前工作目录到指定的路径
例如：在当前aa目录下创建bb目录
os.chdir('aa')
os.mkdir('bb')

7.获取某个文件夹下所有文件和文件夹的名字，返回一个列表

os.listdir(目录)
例如：print(os.listdir()) 返回当前文件夹下
例如：print(os.listdir('文件夹名字')) 返回指定文件夹下

闭包和装饰器

内部函数引用了外部函数的局部变量，那么内部函数就被认为是闭包

def func1(a,b):
    c=100
    def func2():
        s=a+b+c
        print(s)
    return func2  #不能加括号，加括号表示调用

闭包函数作用：

1. 外部函数中定义了内部函数
2. 外部函数是有返回值的
3. 返回值是：内部函数名
4. 内部函数使用了外部函数的变量名

装饰器

装饰器：将被装饰的函数当做参数传递给装饰器对应的函数，并返回包装后的被装饰的函数。

面向对象

先有类，再有对象，用类去实例化一个对象

注意：类名要符合标识符命名规则，一般类名用大写字母开头，函数名用小写字母开头，用于区分

类的基本作用就是封装代码

在Python中，X()的函数叫做魔法方法，指的是具有特殊功能函数。

init()方法的作用：初始化对象

1. 在创建一个对象时默认被调用，不需要手动调用
2. init(self)参数，不需要开发者传递，Python解释器会自动把当前的对象引用传递过去
3. 一个类可创建多个对象，对不同的对象设置不同的初始化属性需要传参数

self = 对象名 由于打印对象名和打印self得到的内存地址相同，所以self指的是调用该函数的对象

一个类可以创建多个对象，但是self地址不相同，因为不同的对象存储的地址不一样

类的专有方法

__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__truediv__: 除运算
__mod__: 求余运算
__pow__: 乘方

异常处理和存储数据

异常的写法：

try:
    可能发生错误的代码
except:
    如果出现异常执行的代码
esle:
    代码没有异常
finally:
    无论是否异常都要执行的代码

返回异常的原因：

try:
    可能发生错误的代码
except Exception as 变量:
    print(变量名)
    

捕获指定异常

try:
    可能发生错误的代码
except 异常类型:
    如果捕获到该异常类型执行的代码

捕获多个指定异常：

try:
    可能发生错误的代码
except （异常元组）:
    =如果捕获到该异常类型执行的代码

捕获多个指定异常并返回错误类型：

try:
    可能发生错误的代码：
except (异常元组类型) as 变量名：
    如果捕获到该异常类型执行的代码

自定义异常类型

raise

json模块

json.dump(要存储的数据,用于存储数据的文件对象) #存储数据到json格式的文件
json.load(用于存储数据的文件对象) #从json格式的文件读取到内存