python基础语法

---

前言

语言：Python（python==3.9）

编译软件：VScode、PyCharm

环境：Anaconda

一、Python注释和输入输出

注释分为单行注释，多行注释，被注释的代码不会运行，快捷键：选中代码+Ctrl+/

主要功能有：

1.对代码进行注释，方便进行理解

2.对代码进行禁用

1.单行注释

# 单行注释
# 我是一个注释 不是运行的代码 写代码的时候：Ctrl+/
# print("hello")
print(123)

**运行结果：**123

2.多行注释

"""
三引号
引号内代码都注释
随便写多少行
"""
print("hello")

**运行结果：**hello

3.输入和输出

# 输出
print("打印文本")
print("打印数字：",123)
print("文本1","文本2","文本3",sep = "-")
print("文本1",end = "\n")
print("文本2",end = "123")
print("文本3",end = "\n")

运行结果：

打印文本
打印数字： 123
文本1-文本2-文本3
文本1
文本2123文本3

# 输入
print(123)
x = input("打印到控制台，让程序暂停，等待用户输入")
print(x)
print(456)

运行结果：

123
444（将在控制台显示“打印到控制台，让程序暂停，等待用户输入”，等到用户输入后再运行下面的程序，这里输入444，输出444）
456

二、变量

什么是变量：用一个简短的名称来代替数据的使用

1.数值

a = 100
print(a)
print(100)

2.字符串

b = "我是一个字符串"
# 声明了一个变量，名字叫b,后面程序运行时可以直接用b来表示
print(b)

3.变量名称的要求

一般场景下必须使用变量来保存数据，如果不需要使用到的数据需要接收，则用下划线“_”表示变量名

x = 123
y = "nihao"
_ = 200
print(x,y,_)

变量名字必须是连续的字母，下划线，数字的组合。错误的命名方法：first name = “123”

firstname = "123123" #不会报错，但是不方便阅读

数字不可以作为变量名的开头，变量名严格区分大小写Name和name是两个不同的变量

1app_version = "1.1.0"
print(1app_version)

官方提供的关键字不可以作为变量名

True = 10

中文作为变量名？可以，只要是Unicode编码符合的字符都可以作为变量名，一般约定用英文或者拼音字母而不用汉字

华清远见 = "华清远见成都分中心在西南交大地铁站旁"
print(华清远见)

常把大写字母的变量名作为不改变的常量使用

PI = 3.14159

4.变量名命名规则

三种写法：

1.小驼峰：huaQingYuanJian

2.大驼峰：AppVersion

3.匈牙利命名法（比较常用）：ai_first_class_1

三、变量的赋值与取值

1.数据直接量

x = 100
x_2 = "hello"
#取出变量中的数据并打印
print(x)

2.表达式

x_3 = x
print(x_3)

3.多变量一起赋值

a = b = c = 100
print(a,b,c)

4.解构赋值

w,m,n = 100,10,1
print(w,m,n)

5.变量的取值

x = 10
x = 1#此时x最后被更新为1
print(x)#必须要等打印出来过后才执行后续的代码

x1 = 10
x2 = 20
x3 = 30
c = 666,x1,x2,x3
print(c)
x1,a,b,c= 666,x1,x2,x3
print(x1,a,b,c)

# 交换两个数据的取值
x1 = 10
x2 = 20
x1,x2 = x2,x1#x1<--x2,x2<--x1同时发生,优先级：先取值后赋值  生成一个元祖(x2,x1)==>(20,10)==>(x1,x2)
print(x1,x2)

四、字符串

1.字符串的写法

x_1 = "我是一个字符串"
x_2 = ""#空字符串
x_3 = " "#空格也是字符串
print(type(x_2))

x1 = "hello"
x2 = "hi"
x3 = """三引号也可以是字符串
可以随意换行
自带换行符
"""
print(x3)

运行结果：

三引号也可以是字符串
可以随意换行
自带换行符

2.转义字符

x1 = "我爱我的祖国和我的家乡\"四川\""
print(x1)
x2 = '我爱我的祖国和我的家乡\'四川\''
print(x2)
x3 = "我爱我的祖国和我的家乡'四川'"
print(x3)
x4 = "你好：\n  欢迎你"
print(x4)
x5 = "abcd\\efg\\hi"
print(x5)
x6 = "abc\tdef\tghi"
print(x6)
x7 = r"D:\桌面\华清\3.8\code\06-字符串.ipynb"#在字符串之前加r，表示\不转义
print(x7)

运行结果：

我爱我的祖国和我的家乡”四川”
我爱我的祖国和我的家乡’四川’
我爱我的祖国和我的家乡’四川’
你好：
欢迎你
abcd\efg\hi
abc def ghi
D:\桌面\华清\3.8\code\06-字符串.ipynb

3.字符串常用运算操作

加号：

x1 = "华清远见"
x2 = "成都分中心"
str_1 = x1 + x2
print(str)

x3 = "我的年龄是："
x4 = "18"
str_2 = x3 + x4#只能字符串和字符串进行连接,两个变量的类型不匹配则不能拼接
print(str_2)

x5 = '华清''远见''666'#多个字符串靠在一起自动变成一个字符串
print(x5)

乘号：

# 乘号
x6 = "abc"
str_3 = x6*3
print(str_3)

运行结果：

华清远见成都分中心
我的年龄是：18
华清远见666
abcabcabc

等号：（严格区分大小写）

x1 = "abc"
x2 = "Abc"
print(x1==x2)

运行结果：

False

4.访问子串

x7 = "华清远见成都分中心"
xx_7 = x7[0]
print(xx_7)

xx_77 = x7[-1]
print(xx_77)

xx__77 = x7[2:10:2]#切片,左闭右开，第三个数字代表每两个选中
print(xx__77)

xx__78 = x7[::2]
print(xx__78)

xx__79 = x7[:6:2]
print(xx__79)

xx__70 = x7[-1:6:2]
print(xx__70)

xx__74 = x7[9:3:-1]
print(xx__74)

运行结果：

华
心
远成分心
华远成分心
华远成

心中分都成

比较常用的三个：

xx__71 = x7[::-1]
print(xx__71)

xx__72 = x7[:-1]
print(xx__72)

xx__73 = x7[-1]
print(xx__73)

运行结果：

心中分都成见远清华
华清远见成都分中
心

5.输入一个字符串，判断是否回文

x1 = input("请输入字符串")# 这里输入：上海自来水来自海上
x2 = x1[::-1]
print(x1==x2)

**运行结果：**True

6.判断一个字符串是否为另一个字符串的子串

x1 = "abcdefg"
x2 = "ab"
x3 = "gh"
print(x1 in x2)
print(x3 in x1)
print(x3 not in x1)

运行结果：

False
False
True

7.查看字符串字符数量(长度)

x1 = "abc"
n = len(x1)
print(n)

**运行结果：**3

8.常见占位符

占位符和类型码

| 占位符和类型码 | 说明                                                         |
| :------------: | ------------------------------------------------------------ |
|       %s       | 转成字符串, 使用 str(x) 函数转换(常用)                       |
|       %d       | 转成十进制的整数(常用)                                       |
|       %o       | 转成八进制的整数                                             |
|     %x,%X      | 转成十六进制的整数                                           |
|     %e,%E      | 转成指数格式的浮点数                                         |
|     %f,%F      | 转成小数格式的浮点数(常用)                                   |
|     %g,%G      | 转成指数格式或小数格式的浮点数                               |
|       %%       | 转成一个%                                                    |
|     %m.nf      | m是指总宽度，默认右对齐，加个 - 表示左对齐，n 是指保留的小数点位数 |

9.字符串格式化表达式

常用来在训练自己的神经网络模型时，控制台查看数据情况

x1 = "我叫%s今年%d岁"%("jack",23)
print(x1)

# 保留小数位数
x2 = "精确度是%.2f"%(100)
print(x2)

# 总宽度
x3 = "精确度是%50.3f"%(100)
print(x3)

# 进制转换
x4 = "十六进制的值是%x"%(11)
print(x4)

# 科学计数法
x5 = "科学计数法表示为%g"%(1000000000)
print(x5)

运行结果：

我叫jack今年23岁
精确度是100.00
精确度是 100.000
十六进制的值是b
科学计数法表示为1e+09

10.另外一种格式化字符串的方式

r = 144
g = 127
b = 255
x1 = "rgb(144,127,255)"
x2 = f"rgb({r},{g},{b})"
print(x1)
print(x2)

运行结果：

rgb(144,127,255)
rgb(144,127,255)

11.字符串常用的一些API(别人写的一些函数，可以直接调用)

# 将字母全部转换为小写
text = "HELLO world"
text2 = text.lower()
print(text2)

# 将字母全部转换为大写
text3 = text.upper()
print(text3)

# 首字母大写
text4 = text.capitalize()
print(text4)

# 去除两边空白字符
text = "  1825648  "
text5 = text.strip()
print(text5)

# 将字符串分割成列表(默认是空格)
text = "hello my name is jack"
text6 = text.split()
print(text6)
# 综合使用
text = "http://www.hqyj.com/index.html?user_id=123&user_name=jack&count=20"
text7 = text.split("?")[0]
print(text7)
text8 = text.split("?")[1].split("&")[1].split("=")[1]
print(text8)

# 连接字符串
text = ['hello', 'my', 'name', 'is', 'jack']
text9 = "-".join(text)
print(text9)

# 字符串替换
text = "你好，我叫李华"
text0 = text.replace("李华","李雷")
print(text0)

# 查找特定字符
text = "hello,my name is lihua"
text11 = text.find("lihua",19)#第二个参数代表起始下标，返回-1表示未查找到 
print(text11)

# 检查字符串是否以指定字符串开头
text = "std = 1"
text12 = text.startswith("std")
print(text12)

# 检查字符串是否以指定字符串结尾，返回布尔类型
text = "std = 1，name"
text13 = text.endswith("name")
print(text13)

# 是否全是数字
text = "1600"
text14 = text.isdigit()
print(text14)

# 是否只包含字母
text = "1600yuan"
text15 = text.isalpha()
print(text15)

# 是否只包含字母和数字字符
text = " price = 1600_yuan"
text16 = text.isalnum()
print(text16)

# 将字符串内每个单词首字母转变为大写
text17 = text.title()
print(text17)

# 将字符串首字母转变为大写
text18 = text.capitalize()
print(text18)

# 统计词频
text = "Hello, World! Hello, Python!"
text19 = text.count("Hello")
print(text19)

# 格式化字符串
name = "jack"
age = 18
text20 = f"my name is {name}, i am {age} year old"
print(text20)

运行结果：

hello world
HELLO WORLD
Hello world
1825648
[‘hello’, ‘my’, ‘name’, ‘is’, ‘jack’]
http://www.hqyj.com/index.html
jack
hello-my-name-is-jack
你好，我叫李雷
-1
True
False
True
False
False
Price = 1600_Yuan
price = 1600_yuan
2
my name is jack, i am 18 year old
False

五、数值型

1.进制

十进制

x = 10

八进制，打印默认转化为十进制数

y = 0o100
print(y)

十六进制

z = 0xD1BfD
print(z)

二进制

m = 0b1010001
print(m)

运行结果：

64
859133
81

2.浮点数与科学计数法

x = 1.0
y = 2.
z = .6

# 科学计数法
x = 1e6
y = 2e03#0没有任何作用
z = 3e-3
import math
PI = math.pi
PI

3.数字类型转换

x = 6
x1 = bin(x)
x2 = oct(x)
x3 = hex(x)
x4 = float(x)
x5 = complex(x)
x = 3.0
x6 = int(x)
print(x1,x2,x3,x4,x5,x6)

math.ceil(x)函数返回大于或等于x的最小整数。
math.floor(x)函数返回小于或等于x的最大整数。

print(math.ceil(3.14))
print(math.floor(3.94))

运行结果：

0b110 0o6 0x6 6.0 (6+0j) 3
4
3

4.布尔类型

x = 0
print(bool(x))
y = ""
print(bool(y))
z = "0"
print(bool(z))
# 空的集合，列表，字符串都是True
print(10<20)

运行结果：

False
False
True
True

5.字节串和空值

# 字节串
text = b"hello"
print(type(text))

# 空值
x = None#表示没有
print(x)

六、列表

1.字面量

x = []
print(type(x))
x = [1, 2, 3, 4, 5]
print(x)
x = [1, 2, [3,4]]
print(x)

2.通过构造函数来创建列表

x = list()
print(x)

3.list函数可以传入一个可迭代对象用于创建列表中数据

x = list("hello")
print(x)
# 或者
x = list(range(10))
print(x)

4.列表的运算

y = [4,5,6]
num = 5
z = x + y
print(z)
# 不能列表乘以列表，不能列表乘以浮点数
print(z)
z = x * num

5.in / not in

x = ["a","b","c"]
print("a" in x)
print("b" not in x)

6.列表切片

lst = [1,5,6,9,8,10]

# lst[起始下标:终止下标:步长]

# 取出一个元素

Lst_1 = lst[2]

# 取出多个元素

lst_2 = lst[2:5:2]

# 列表翻转

lst_3 = lst[::-1]

print(Lst_1,lst_2,lst_3)

运行结果：

6 [6, 8] [10, 8, 9, 6, 5, 1]

7.列表的操作

x = [10, 20, 30]
re = x.append(40)# 直接修改列表，在列表末尾添加一行新数据
print(x,re)

x.insert(2,666)# 在索引为2的地方插入666
print(x)

# 可以传入一个可迭代对象
x.extend([9,99,999])
print(x)

# id函数可以查看一个变量保存的数据的地址
x_1 = [1,2,3]
print(id(x_1))
x_2 = [1,2,3]
x_3 = x_1 + x_2
x_1.extend(x_2)
print(id(x_1))
print(id(x_2))#不改变id地址
print(id(x_3))

# 修改，删除数据
x = [1,2,3,5,6,8,9,7,1,2]
x[2] = 666
print(x)
# 切片可以越界
print(x[2:100])
# 传入元素
x.remove(666)
print(x)
# 传入下标
x.pop(1)
print(x)
x.clear()
print(x)

# 删除变量，变量名不在支持被引用
x = [1,2,3,5,6,8,9,7,1,2]
del x
# print(x)报错

x = [1,2,3,5,6,8,9,7,1,2]
# 寻找第一个出现元素的下标
print(x.index(1))
print(x.index(max(x)))

运行结果：

[10, 20, 30, 40] None
[10, 20, 666, 30, 40]
[10, 20, 666, 30, 40, 9, 99, 999]
2303722066048
2303722066048
2303722068160
2303722005568
[1, 2, 666, 5, 6, 8, 9, 7, 1, 2]
[666, 5, 6, 8, 9, 7, 1, 2]
[1, 2, 5, 6, 8, 9, 7, 1, 2]
[1, 5, 6, 8, 9, 7, 1, 2]
[]

0
6

七、元组

元组和列表一样是保存数据的容器

1.创建元组

x = ()
x = (1,2,3,5,6,8,5,4,2,5)
print(x)
print(x[1])
print(x[2:5])#得到一个新元组

# 只有一个数据,在后面打逗号
x = (10)
y = (10,)
print(type(x))
print(type(y))

x = 10,"hello",True
print(type(x))

x = tuple(range(5))
print(x)

运行结果：

(1, 2, 3, 5, 6, 8, 5, 4, 2, 5)
2
(3, 5, 6)
<class ‘int’>
<class ‘tuple’>
<class ‘tuple’>
(0, 1, 2, 3, 4)

2.元组的操作

x = (1,"name","jack",6,5)
# 删除变量
# del x
print((x[1]))

3.解构赋值

解构赋值必须左右的结构一致

x1,x2 = (10,20)
print(x1,x2)

4.元组的运算

x = (10,20)
y = (30,40)
print(x+y)
print(x * 3)

5.将其他数据类型转换为元组

x_1 = [1,2,5,6]
x_2 = "nihao","yes","no"
print(tuple(x_1),tuple(x_2))

count = x_2.count("no")
print(count)

八、字典

1.创建空字典

字典的元素没有下标，只有键和值

d = {}
print(d)
d = dict([("name","xiaowang"),("age",18)])
print(d)
d = dict(a = 1, b = 2, c = 3)
print(d)
# 字典的键不可以重复，否则后一个会覆盖前一个
title = {"name":"jack","age":"18","age":"10"}
print(title["age"])
# 并且需要是不可变类型，以此来访问数据，字典的键不存在会报错
title = {"name":"jack","age":"18","home":"beijing"}
print(title)
d = {(1,2,3):"id_num","age":18}
print(d)

运行结果：

{}
{‘name’: ‘xiaowang’, ‘age’: 18}
{‘a’: 1, ‘b’: 2, ‘c’: 3}
10
{‘name’: ‘jack’, ‘age’: ‘18’, ‘home’: ‘beijing’}
{(1, 2, 3): ‘id_num’, ‘age’: 18}

2.字典的操作

# 添加和修改和访问
title = {"name":"jack","age":18,"home":"beijing"}
title["age"] = 20
print(title)
title["school"]="swust"
print(title)
print(title["home"])

运行结果：

{‘name’: ‘jack’, ‘age’: 20, ‘home’: ‘beijing’}
{‘name’: ‘jack’, ‘age’: 20, ‘home’: ‘beijing’, ‘school’: ‘swust’}
beijing

3.in/not in

只能用来判断键

title = {"name":"jack","age":18,"home":"beijing"}
print("name" in title)
print("jack" in title)

运行结果：

True
False

4.删除字典

title = {"name":"jack","age":18,"home":"beijing"}
del title["name"]
print(title)
title.clear()
print(title)
del title

运行结果：

{‘age’: 18, ‘home’: ‘beijing’}
{}

5.常见API

title = {"name":"jack","age":18,"home":"beijing"}
print(len(title))
print(type(title))

运行结果：
3
<class ‘dict’>

把字典的字面量变成字符串，网络传输的时候，常常会把这种格式的字符串进行传输（JSON）

str1 = str(title)
print(str1,type(str1))

运行结果：
{‘name’: ‘jack’, ‘age’: 18, ‘home’: ‘beijing’} <class ‘str’>

6.字典的一些方法

title = {"name":"jack","age":18,"home":"beijing"}
# 清空字典
title.clear()
print(title)

# 浅复制,存储地址不一样
# 因此更改其中一个不会对另外一个产生任何影响
title = {"name":"jack","age":18,"home":"beijing"}
str1 = title.copy()
print(str1)
print(id(title),id(str1))
str1["name"] = "mary"
print(str1,title)

# 获取字典中的数据
str2 = title.get("age")
print(str2)
str2 = title["age"]
print(str2)

# 若访问的键不存在，直接返回default的值
str2 = title.get("nn","None")
print(str2)

# 以可迭代对象来返回视图对象
items = title.items()
print(type(items))
for key,value in items:
    print(key,value)

# 返回键名
keys = title.keys()
for key in keys:
    print(key)

# 返回键值
values = title.values()
for value in values:
    print(value)

title_1 = {"name":"jack","age":18,"home":"beijing"}
title_2 = {"food":"vegetable"}
# 将title_2添加到title_1中
title_1.update(title_2)
print(title_1)

# 删除字典的某个键
title.pop("name")
# 也可以将age的值置空，但是键仍然占用空间
title["age"] = None
print(title)

运行结果：

{}
{‘name’: ‘jack’, ‘age’: 18, ‘home’: ‘beijing’}
2594022048448 2594031191872
{‘name’: ‘mary’, ‘age’: 18, ‘home’: ‘beijing’} {‘name’: ‘jack’, ‘age’: 18, ‘home’: ‘beijing’}
18
18
None
<class ‘dict_items’>
name jack
age 18
home beijing
name
age
home
jack
18
beijing
{‘name’: ‘jack’, ‘age’: 18, ‘home’: ‘beijing’, ‘food’: ‘vegetable’}
{‘age’: None, ‘home’: ‘beijing’}

九、集合

1.创建集合

s1 = set()
print(s1)

# 传入数据是可迭代对象
# 自动排序
s2 = set([1,2,3,8,5])
print(s2)
s2 = set(range(5))
print(s2)

s3 = {10,20,30}
print(s3)

集合中不存在相同元素并且元素需要是不可变类型

s4 = {10,20,(2,3),10,1}
print(s4)

易混点

s5 = {(10)}

print(s5)

s6 = {(10,),(10,),}

print(s6)

运行结果：

{10}

{(10,)}

只有在python中相等，比较的是元素的值而不是地址

x = (10,20)
y = (10,20)
print(x==y)
print(id(x)==id(y))

2.案例

假设有一万个数字，每一个数字代表张图片的类别，用集合来查看到底有多少种类别

x = [0,0,0,0,1,1,1,1,2,2,4,4,4,4,4,4,2,2,1,1,1,1,0,0,0,0,3,3,3,3,3,5,1,2,2,1]

print(set(x))

3.固定集合

不可以更改元素

s1 = frozenset([1,2,3,4,5,5,6])

print(s1)

4.eval()函数

常出现在企业级别的项目中,向项目中添加代码

str1 = "10+20"

eval(str1)

lst = [1, 5, 6, 4, 5, 2, 3]

str2 = "+".join(map(str, lst))  # 将整数转换为字符串

print(eval(str2))

十、运算符

1.逻辑运算符

A and B

A是一个表达式，B也是一个表达式

如果bool(A)为False，那么B不运行，否则整个表达式的结果为B的结果

x1 = 100
x2 = 200
x3 = 0
x = x1 and x2
print(x)

x = x3 and x2
print(x)

运行结果：

200
0

A or B

如果bool(A)为True，那么B不运行，否则整个表达式的结果为B的结果

x = x1 or x2
print(x)
x = x3 or x2
print(x)

运行结果：

100
200

not A

如果bool(A)为True，那么not A的结果为False，否则not A的结果为True

x = not x1
print(x)
x = not x3
print(x)

运行结果：

False
True

2.位运算符

x1 = 0b1010

x2 = 0b1100

# 默认输出十进制数

print(x1 & x2)#按位与

print(x1 | x2)#按位或

print(x1 ^ x2)#按位异或

print(~x1)#按位取反

运行结果：

8

14

6

-11

x1 = x1^x2

x2 = x1^x2

x1 = x1^x2

print(x1,x2)

运行结果：

12 10

左移运算符

左移运算符是将一个数字的二进制位全部左移若干位，高位丢弃，低位补0。

x1 = 0b1010

x2 = 2

print(x1 << x2)#左移运算符

右移运算符是将一个数字的二进制位全部右移若干位，低位丢弃，高位补0。

右移运算符

x1 = 0b1010

x2 = 2

print(x1 >> x2)#右移运算符

运行结果：

40

2

3.身份运算符

a = 10
b = 10
print(a is b)  # True
print(a is not b)  # False

4.成员运算符

a = [1, 2, 3, 4, 5]
b = 3
print(b in a)  # True
print(b not in a)  # False

5.三元运算符

a = 10
b = 20
result = a if a > b else b
print(result)

运行结果：

20

十一、表达式

\1. 算术表达式

\2. 逻辑表达式

\3. 关系表达式

\4. 赋值表达式

\5. 条件表达式

\6. 位运算表达式

\7. 成员运算表达式

\8. 身份运算表达式

十二、语句

标准的语句写法是每一个语句结束以后 用分号结尾

例如x = 10;，但是python不需要分号

语句分为单行语句和多行语句

1.if语句

if 1 == 1:
    print("1 == 1")
else:
    print("1 != 1")

if 1 == 1:
    print("1 == 1")
elif 1 == 2:
    print("1 == 2")
else:
    print("1 != 1")

2.循环语句

# for循环
for i in range(2, 10,2):
    print(i)

# while循环
i = 1
while i <= 10:
    print(i)
    i += 1
else:
    print("循环结束")

# 死循环
# while True:
#     print("永远不会结束")

3.break和continue语句

# break语句
# break语句用于终止当前循环，并跳出循环体。
# python代码示例：

# 1. 无限循环
i = 0
while True:
    print(i)
    i += 1
    if i == 5:
        break

# 2. 条件循环
for i in range(10):
    if i == 5:   # 当i等于5时，跳出循环
        break
    print(i)
# continue语句
# continue语句用于跳过当前循环的剩余语句，直接开始下一轮循环。
# python代码示例：

for i in range(10):
    if i == 5:   # 当i等于5时，跳过当前循环的剩余语句，直接开始下一轮循环
        continue
    print(i)

4.推导式

# 列表推导式
x2 = [i**2 for i in range(1, 11) if i%2 == 0]
print(x2)
# 元组推导式
x3 = tuple(i**2 for i in range(1, 11))
print(x3)

# 字典推导式
key = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k']
x4 = {key[i]: i**2 for i in range(1, 11)}
print(x4)

# 集合推导式
x5 = {i**2 for i in range(1, 11)}
print(x5)

运行结果：

[4, 16, 36, 64, 100]
(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)
{‘b’: 1, ‘c’: 4, ‘d’: 9, ‘e’: 16, ‘f’: 25, ‘g’: 36, ‘h’: 49, ‘i’: 64, ‘j’: 81, ‘k’: 100}
{64, 1, 4, 36, 100, 9, 16, 49, 81, 25}

5.with语句

# with语句
with open("test.txt","r") as f:
  print(f)
  for line in f:
    print(line)
# with自动关闭文件


f = open("test.txt","r")
print(f)
for line in f:
  print(line)
f.close()# 手动关闭文件

十三、函数

1.声明函数

def f1():
  print("f1运行")
f1()

def f2(x1,x2):
  print(x1+x2)
f2(5,6)

return会让函数停止执行并返回结果

def f2(x1,x2):
  return x1+x2
a = f2(6,6)
print(a)

运行结果：

f1运行
11
12

2.参数的数量和位置

# 参数数量和位置一致
def add(a, b):
    # return a + b
    return b + a

print(add(2, 3)) # 5

# 参数数量不一致
# def add(a, b):
#     return a + b + c
# print(add(2, 3)) # 语法错误，缺少参数c

3.关键字参数

先定义默认值，然后再调用时传入关键字参数

def my_func(a, b, c=0, d=0):
    return a + b + c + d

print(my_func(1, 2, 3, 4)) # 10
print(my_func(1, 2, d=4)) # 6

4.元组解包参数

def fn(a,b,c,*args):
  print(a,b,c)
  print(args,type(args))
fn(1,2,3)
fn(5,3,6,8,9,5,4,8)

def fn(*args):
  # 任意传几个参数
  print(*args)

fn(5,6,8)

运行结果：

1 2 3
() <class ‘tuple’>
5 3 6
(8, 9, 5, 4, 8) <class ‘tuple’>
5 6 8

5.字典解包参数

def fn(a,b,**args):
  print(a,b)
  print(args,type(args))

fn(20,30)
fn(10,20,name="jack",age = "18")

运行结果：

20 30
{} <class ‘dict’>
10 20
{‘name’: ‘jack’, ‘age’: ‘18’} <class ‘dict’>

**args 与 *kwargs一起使用，可以接收任意数量的位置参数和关键字参数。

def my_func(*args, **kwargs):
    print(args)
    print(kwargs)

my_func(1, 2, 3, a=4, b=5)  

运行结果：

(1, 2, 3)
{‘a’: 4, ‘b’: 5}

只要是有下标的参数都可以解包

# 列表也可以解包
my_list = [1, 2, 3]
my_func(*my_list)  # 解包
# 也可以用字典解包
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_func(**my_dict)  # 解包
# 元组也可以解包
my_tuple = (1, 2, 3)
my_func(*my_tuple)  # 解包
# 字符串也可以解包
my_str = '123'
my_func(*my_str)  # 解包

6.占位符

def my_func(x, *, y):
  # *是一个占位符，他后面的参数必须是关键字参数
  print(x, y)
# my_func(1,2)报错，缺少关键字参数y
my_func(1, y=2)

7.匿名函数lambda

fn=lambda x,y:x+y
print(fn(2,3))

fn = lambda x:"奇数" if x%2==1 else "偶数"
print(fn(11))
print(fn(2))

案例1：判断是否是闰年

def is_leap(year):
  if (year%4)==0 and (year%100)!=0:
    return True
  elif (year%400)==0:
    return True
  else:
    return False
print(is_leap(2024))

案例2：按比例划分数据集

def train_test_split(data,train_size = 0.8):
    train_data = data[:int(len(data)*train_size)]
    test_data = data[int(len(data)*train_size):]
    return train_data,test_data
#测试
data = [1,2,3,4,5,6,7,8,9,10]
train_data,test_data = train_test_split(data,0.8)
print(train_data)
print(test_data)

运行结果：

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

函数分为三种：

官方内置函数，第三方函数，自己写的函数

8.官方内置函数

# all传入的参数全部为True就返回True
x = [-10,0,30,-2]
re = all(x)
print(re)
# any只要有一个为True就返回True
print(any(x))
# sum(x)对x求和
print(sum(x))
# sorted(x)排序，key = fn表示按照函数返回值排序
def fn(x):
  return x**2
print(sorted(x,key = fn))
# reverse(x)反转，返回一个可迭代对象
print([i for i in reversed(x)])
# callable(x)检测x标识符是不是能够当函数调用
fn = 100
print(callable(fn))
fn = lambda x,y:x+y
print(callable(fn))
# zip(x,y)将x,y两个数据容器组合成一个可迭代对象,打包成元组
x = [10,20,30,40,50]
y = [40,50,60]
print([i for i in zip(x,y)])
# exec()将传入的字符串中的代码执行
exec("print('hello')")

运行结果：

False
True
18
[0, -2, -10, 30]
[-2, 30, 0, -10]
False
True
[(10, 40), (20, 50), (30, 60)]
hello

9.globals和locals()

globals()返回值是一个字典，字典的key就是当前python环境全局变量的名字

x = 10
y = 20
print(globals())

运行结果是一大串字典

locals()返回值是一个字典，字典的key就是当前函数的局部变量的名字

def fn(x,y):
  print(locals())
fn(1,2)

运行结果：

{‘x’: 1, ‘y’: 2}

10.filter函数

filter(函数，可迭代对象)，传入两个参数：函数和可迭代对象，返回一个经过函数筛选后的可迭代对象

x = [1,2,2,3,5,6,4,8,5,2]
x2 = filter(lambda el:el%2==1,x)
print(list(x2))

实现：

def myfilter(fn,x):
  x2 = []
  for i in x:
    if fn(i) ==True:
      x2.append(i)
    else:
      continue
  return x2
def fn(x):
  if x%2==0:
    return True
  else:
    return False
re = myfilter(fn,[1,2,2,3,5,6,4,8,5,2])
print(re)

运行结果：

[2, 2, 6, 4, 8, 2]

11.map函数

map(函数，可迭代对象),与filter不同的是不需要进行筛选，直接经过函数映射到可迭代对象中

x = [1,2,2,3,5,6,4,8,5,2]
def fn(x):
  return x**2
print(list(map(fn,x)))

实现

def mymap(fn,x):
  x2 = []
  for i in x:
    x2.append(fn(i))
  return x2
def fn(x):
  return x**2
re = mymap(fn,[1,2,2,3,5,6,4,8,5,2])
print(re)

运行结果：

[1, 4, 4, 9, 25, 36, 16, 64, 25, 4]

12.reduce函数

reduce(函数，可迭代对象，初始值）

reduce()函数会对可迭代对象中的元素进行累积操作，并将结果作为第一个参数传递给函数，然后再将结果和第二个参数传递给函数，以此类推，直到可迭代对象中的所有元素都被处理完。最后，reduce()函数返回累积结果。

from functools import reduce
x = [1,2,4,3,5,6,4,8,5,2]
def fn(x1,x2):
  print(x1,x2,"=====")
  return x1+x2

reduce(fn,x)

实现：

def myreduce(fn,x,start):
  x1 = fn(start,x[0])
  for i in range(len(x)-1):
    x1 = fn(x1,x[i+1])
  return x1
  # 简洁版 
  # def myreduce(fn,x,start):
  # re = start
  # for i in x:
  #   re = fn(re,i)
  # return re

def fn(x1,x2):
  print(x1,x2,"=====")
  return x1+x2
x = [1,2,4,3,5,6,4,8,5,2]
myreduce(fn,x,0)

运行结果：

0 1 =====
1 2 =====
3 4 =====
7 3 =====
10 5 =====
15 6 =====
21 4 =====
25 8 =====
33 5 =====
38 2 =====

13.作用域

作用域只针对函数，函数内部可以访问函数内部和外部的变量，但是函数外部不能访问函数内部的变量

a = 100
def fn():
  q = 10
  a = 20#内层有a，访问内层作用域的a，外层没有，就去外层的外层，如果都没有就报错
  print(a)
  print(q)
  return a+q
print(fn())# 每次调用函数内部都会产生一个作用域，调用完毕后，内部创建数据使用的内存销毁
print(a)
# print(q)报错

运行结果：

20
10
30
100

b = [1,2,3,4,5,lambda x:x+1]
print(b[5](5))

运行结果：

6

函数调用在A作用域 定义在B作用域，函数无论在哪个作用域中执行，一定是他定义的作用域下执行代码

a = 100
def fm():
  print(a)

def fn():
  a = 200
  fm()

fn()

运行结果：

100

函数也是一种数据

def f1():

  a = 100

  def f2():

    print(a)

  return f2

a = 200

re = f1()

re()# 执行函数

作用域案例：

def fun(n = None,o = None):
  print(o)
  return {"fun":lambda m:fun(m,n)}

a = fun(0)
a["fun"](1)
a["fun"](2)
a["fun"](3)

b = fun(0)["fun"](1)["fun"](2)["fun"](3)

c = fun(0)["fun"](1)
c["fun"](2)
c["fun"](3)

运行结果：

None
0
0
0
None
0
1
2
None
0
1
1

14.修改变量值

# def fn():
#   print(a)
#   a = 2
# fn()报错

a = 10
def fn():
  global a#声明全局变量
  print(a)
  a = 20#会访问全局变量a的值
fn()
print(a)


a = 10
def fn():
  global a
  a = 20
  def fm():
    global a
    print(a)#访问和修改全局作用域“a = 10”这个a
    a = 30
  fm()
fn()


a = 10
def fn():
  a = 20
  def fm():
    nonlocal a#访问和修改外层作用域“a = 20”这个a
    print(a)
    a = 30
  fm()
fn()

运行结果：

10
20
20
20

15.内建作用域

print(__name__)

运行结果：

main

16.递归

def f(a):
  if a > 5:
    return a
  else:
    return f(a+1)

r = f(0)
print(r)

运行结果：

6

函数返回值是一种数据，函数也是一种数据

def fn():
  return 1+1
print(type(fn))
print(type(fn()))

运行结果：

<class ‘function’>
<class ‘int’>

16.回调函数 callback

把一个函数传入另外一个函数，传入的函数就是回调函数

定义一个工具函数，传入两个数和一个函数，调用传入的函数并返回结果

a,b可以是数据也可以是字符串，func必须是函数

# 定义两个函数
def add(a,b):
  return a+b
def sub(a,b):
  return a-b
def calculate(a,b,func):
  return func(a,b)

# 传进去的add就是回调函数
print(calculate(5,3,add)) # 8
print(calculate(5,3,sub)) # 2

回调函数怎么体现：

遍历：把一个数据容器中的数据全部拿出来调用

设计一个工具函数：遍历列表中的所有元素，找出奇数拿来使用，但是这个工具自己并不适用

而是交给业务函数（回调）使用

def find_odd(arr,cb):
  for el in arr:
    if el%2==1:
      cb(el)

x = [2,5,6,8,9,7]
def print_odd(el):
  print("找到一个奇数：",el)
find_odd(x,print_odd)
find_odd(x,lambda m:print(m**2))

运行结果：

找到一个奇数： 5
找到一个奇数： 9
找到一个奇数： 7
25
81
49

17.闭包函数 block

函数内部有函数，内部的那个函数就是闭包函数

1.由于函数有作用域，而且多个函数的作用域是相互独立的

使用闭包函数把函数的值单独保存，让变量不要相互污染

2.由于函数调用和定义的作用域可以不是同一个，并且函数调用时是在定义的作用域中执行的

因此闭包函数可以在函数外部访问函数内部的变量

def alipay():
  money_in = 100
  def tool():
    money_in = 300
    print(money_in)
  return tool
re = alipay()
re()
money_out = 200
print(money_out)
# print(money_in) 报错并没有更改程序内部的money，而是外部变量的money

案例

# 案例
def alipay():
  money1 = 200
  def tool(pwd,new_money):
    nonlocal money1
    if pwd == 123:
      money1 = new_money
    print(money1)

  def withdraw(pwd,amount):
    # 取钱
    nonlocal money1
    if pwd == 123:
      money1 -= amount
    print(money1)

  return tool,withdraw


def meituan():
  tool,withdraw = alipay()
  tool(123,666)
  # fn(321,777)

  withdraw(123,50)
meituan()

运行结果：

666
616

十四、装饰器

参考：一文搞懂Python装饰器（通俗易懂） - 知乎

装饰器相当于一个闭包的调用，但是不同的是相较于Alipay的案例，不需要多余构建re变量，直接用@装饰器名字的方式来调用，相当于一种方便的写法

装饰器本质是回调函数和闭包函数的结合

装饰器本身是一个函数，把装饰的函数作为参数输入，然后吧调用封装在内部的闭包中，返回值那个闭包

不带参数的装饰器

def fn():
  print("fn函数的业务是答应一句话：未来业务可能有很多行代码")


# 设计一个装饰器

def decorator(cb):
  def block1():
    print("装饰器执行的代码：怎么装饰由业务决定")
    cb()
    print("装饰器可以继续装饰：怎么装饰由业务决定")
  return block1

@decorator
def fn2():
  print("fn2函数的业务是打印一句话：未来就是具体业务代码")

fn2()

运行结果：

装饰器执行的代码：怎么装饰由业务决定
fn2函数的业务打印是一句话：未来就是具体业务代码
装饰器可以继续装饰：怎么装饰由业务决定

带参数的装饰器：

# 带参数的装饰器
def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Before calling the function")
        func(*args, **kwargs)
        print("After calling the function")
    return wrapper

@my_decorator
def my_function(x, y):
    print("The sum of", x, "and", y, "is", x+y)
    return x + y

my_function(2, 3) # Output: 5  

运行结果：

Before calling the function
The sum of 2 and 3 is 5
After calling the function

作用：

1. *日志记录*：在函数执行前后自动添加日志记录，方便调试和监控程序行为。
2. *性能测试*：装饰器可以用来测量函数的执行时间，帮助识别性能瓶颈。
3. *权限验证*：在Web开发中，装饰器可以用于检查用户是否有权访问某个资源或执行特定操作。
4. *缓存*（Memoization）：通过装饰器实现函数结果的缓存，避免重复计算相同的输入值，从而提高效率。

十五、面向对象

1.类和对象的语法

定义一个类

class Person:
  name = "张三"
  age = 18
  life = 1

  def fn(self,num):
    print("类中的函数叫做方法，参数是",num)

print(Person,type(Person))

用这个类创造对象

p1 = Person()
print(p1,type(p1))

对象内部保存了很多数据，想要访问需要通过成员名

语法：对象名.成员名

print(p1.name,p1.age,p1.life)

p1.fn(1)


p2 = Person()
p2.fn(2)

运行结果：

<class ‘__main__.Person’> <class ‘type’>
<__main__.Person object at 0x00000187F9C19940> <class ‘__main__.Person’>
张三 18 1
类中的函数叫做方法，参数是 1
类中的函数叫做方法，参数是 2

2.init

实用类创建对象时，可以初始化对象的成员的值

但是在Python当中__init__并不是构造函数，__new__才是

__init__是一个魔术方法，是一个特殊的函数，会在创建对象时调用

class Teacher:
  # 类名（10,20）的10和20会传给__init__函数的参数
  def __init__(self,name,age):
    print("__init__ name:",name,"年龄：",age)
    self.n = name# 给t1对象添加一个属性，属性名是n，属性中保存的值是：“xiaoming”，相当于赋值
    self.a = age
    

  def fn(self,name,age):
    print("fn name:",name,"年龄：",age)

t1 = Teacher("xiaoming",18)
t1.fn("xiaoming",18)
t1.a

运行结果：

init name: xiaoming 年龄： 18
fn name: xiaoming 年龄： 18

类每次创建对象时，创建对象有同样的属性和方法，而有一部分是创建的时候赋的值，有一部分创建的时候值一样

class Game_person:
  life = 1
  def __init__(self,name,rank):
    self.name = name#前一个name是self的属性，后一个name是函数内部的一个变量
    self.rank = rank

# 可以创建很多个
g1 = Game_person("boss",2000)
g2 = Game_person("npc",100)
print(g1.name,g1.rank)
print(g2.name,g2.rank)

运行结果：

boss 2000
npc 100

3.对象语法

class Box:
  x = 100
  def __init__(self,y):
    self.y = 200
  
  def change_y(self,new_y):
    print("调用函数前",self.y )
    self.y = new_y
    print("调用函数后",self.y )

b1 = Box(99)
b1.x = 200
print(b1.x)#只修改了b1的x值

b2 = Box(98)
print(b2.x)#b1的x值不变

b3 = Box(97)
print(b3.y)#这里y还是200

# 修改y的值,这里只修改b3的值，b1,b2不受影响，但是b1,b2也可以调用这个方法来修改值
# 第一种直接修改：
b3.y = 1
print("直接修改后",b3.y)
# 第二种常见一个修改y的函数来修改self.y：
b3.change_y(2)
print(b3.y)

运行结果：

200
100
200
直接修改后 1
调用函数前 1
调用函数后 2
2

4.对象的方法内部可以操作这个对象的属性和方法

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_hello(self):
        print("Hello, my name is {} and I am {} years old.".format(self.name, self.age))

p1 = Person("Alice", 25)
p1.say_hello()

运行结果：

Hello, my name is Alice and I am 25 years old.

5.对象的方法可以传入参数，也可以返回值。

class Box:
  count = 100
  def __init__(self,m):
    self.m = m
  def cal_total(self,price):
    return self.count*self.m*price
  
b1 = Box(45)
re = b1.cal_total(108)
print(re)

运行结果：

486000

案例1

假设有一个ATM类 用这个类创建出来的对象就是一个取款机对象

atm对象有一个属性 是一个列表 里面装了很多对象，每一个对象就是一个Person类型的对象

有一个属性 是一个数字 保存了余额

有一个方法可以往ATM里面添加Person对象

class Person:
  def __init__(self,name,card_num,phone_num):
    self.name = name
    self.card_num = card_num
    self.phone_num = phone_num

class ATM:
  money = 5000
  persons = []
  def add_person(self,person):
    if person not in self.persons:
      self.persons.append(person)
      print("添加成功")
    else:
      print("该卡号已存在")

atm = ATM()
person1 = Person("张三","123456","13800138000")
person2 = Person("李四","654321","13800138001")
atm.add_person(person1)
atm.add_person(person2)
print(atm.persons[0].name)
print(atm.persons[0].card_num)
print(atm.persons[0].phone_num)

运行结果：

添加成功
添加成功
张三
123456
13800138000

案例2：

公司员工管理系统

设计一个公司员工管理系统，包含以下内容：

\1. 定义一个 Employee 类，包含以下属性：

- name（姓名）

- position（职位）

- salary（薪水）

\2. 定义一个 Company 类，包含以下内容：

- 一个列表属性，用于存储 Employee 对象。

- 一个方法 hire_employee，用于招聘新员工。

- 一个方法 fire_employee，根据员工的姓名，解雇该员工。

- 一个方法 list_employees，用于列出公司中所有员工的信息。

- 一个方法 total_salary，计算公司所有员工的总薪水。

\3. 测试代码：

- 创建一个 Company 对象。

- 招聘几个员工。

- 列出所有员工。

- 解雇一个员工。

- 再次列出所有员工。

- 打印公司总薪水。

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

class Company:
  Employee_lst = []

  def hire_employee(self,Employee):
    if Employee not in self.Employee_lst:
      self.Employee_lst.append(Employee)
    else:
      print("已经添加该员工")

  def list_employees(self):
    for Employee in self.Employee_lst:
      print("name:",Employee.name,"position:",Employee.position,"salary:",Employee.salary)

  
  def total_salary(self):
    salary_total = []
    for Employee in self.Employee_lst:
      salary_total.append(int(Employee.salary))
    return sum(salary_total)

person1 = Employee("张三","经理","5000")
person2 = Employee("李四","客服","3000")
person3 = Employee("王五","地推","1000")

ali = Company()
ali.hire_employee(person1)
ali.hire_employee(person2)
ali.hire_employee(person3)

ali.list_employees()

salary = ali.total_salary()
print(salary)

运行结果：

name: 张三 position: 经理 salary: 5000
name: 李四 position: 客服 salary: 3000
name: 王五 position: 地推 salary: 1000
9000

6.类属性和类方法

class qox:
  x = 100#他是一个类属性，这个类创建出来的实例也能访问
  def fn(self):
    print(qox.x)

# 两种调用方式
print(qox.x)
b1 = qox()
print(b1.x)

b1.x = 500
print(b1.x)#被更改
print(qox.x)#没有被更改，说明类自己本身也是一种数据容器
b1.fn()

运行结果：

100
100
500
100
100

7.类属性和类方法

它接收类本身作为第一个参数（通常命名为 cls），而不是实例（self）。

类方法可以访问类的属性和方法，但不能访问实例的属性

类变量是在类的定义中直接定义的变量，而不是在类的 init 方法或其他实例方法中定义的。

类变量属于类本身，而不是属于类的某个实例

class qox:
  x = 100#他是一个类属性，这个类创建出来的实例也能访问
  def fn(self):
    print(qox.x)

# 两种调用方式
print(qox.x)
b1 = qox()
print(b1.x)

b1.x = 500
print(b1.x)#被更改
print(qox.x)#没有被更改，说明类自己本身也是一种数据容器
b1.fn()

显式的指定类方法

class Box:
  x = 100
  def __init__(self,y):
    self.y = y
  def fn(self):
    print(self.x)
  
  @classmethod
  def fm(cls):
    print("fm被调用")
    print(cls.x)

b1 = Box(100)
# b1对象可以使用的成员：x,y属性,y方法 fn方法,fm方法
print(b1.x)
print(b1.y)
b1.fn()
b1.fm()

# Box可以直接访问fm
Box.fm()

案例：类方法常可以作为工厂方法

class single:
  instance = None
  
  # 类方法：
  @classmethod
  def share_instance(cls):
    if cls.instance is None:
      cls.instance = single() 
      return cls.instance
    else:
      return cls.instance
    
s1 = single.share_instance()
s2 = single.share_instance()
# 两个是一样的
print(s1)
print(s2)

o1 = single()
o2 = single()
# 两个是不同的
print(id(o1))
print(id(o2))

批量创建对象

class student:
  def __init__(self, name, age):
    self.name = name
    self.age = age
  
  @classmethod
  def create_students(cls,num):
    arr = []
    for i in range(num):
      arr.append(cls(f"student{i}", i))
    return arr

# 直接创建两个学生对象
s1 = student("Alice", 20)
s2 = student("Bob", 21)
print(s1.name, s1.age)
print(s2.name, s2.age)

# 先初始化好学生数量，再去更改学生的属性
students = student.create_students(10)
students[0].name = "jack"
students[0].age = 22
print(students[0].name, students[0].age)

8.静态方法

静态方法通常用于实现一些与类无关的工具函数，这些函数不需要访问类或实例的属性。

它们可以被类或实例调用，但不会影响类或实例的状态。

class Box:
  count = 0
  def fn(self):
    print("fn普通方法")
  @classmethod
  def fm(cls):
    print("fm类方法")
  @staticmethod
  def fz():
    print("fn静态方法")
  @staticmethod
  def sigmod(x):
    return 1.0/(1.0+math.exp(-x))

Box.fm()
Box.fz()

b1 = Box()
b1.fz()

re = Box.sigmod(10)
print(re)

9.构造方法

静态方法__new__ 方法负责创建并返回类的新实例，而 init 方法则用于初始化实例。

class Box:
  def __new__(self):
    print(self)
    return super().__new__(self)
  def __init__(self):
    self.width = 0

b1 = Box()
print(b1.width)
print(b1,Box)

10.魔术方法

class Person:
  # 初始化方法
  def __init__(self, name, age):
    self.name = name
    self.age = age

  # 打印方法
  # 打印对象时，会调用该方法
  # 该方法返回一个字符串，表示对象的信息
  def __str__(self):
    return f"Person(name={self.name}, age={self.age})"
  
  # 
  def __repr__(self):
    # 该方法返回一个字符串，表示对象的信息
    # 该字符串可以被eval()函数解析，得到一个与该对象相同的对象
    # 该方法的作用是方便调试
    return f"Person(name={self.name}, age={self.age})"
  
  def __delitem__(self):
    # 删除对象时，会调用该方法
    print("删除对象")
    del self.name

  def __add__(self, other):
    # 实现两个对象相加,可以自己定义对象与对象的相加规则
    # 该方法返回一个新的对象
    return Person(f"{self.name}+{other.name}", self.age + other.age)
  
  def __sub__(self, other):
    # 实现两个对象相减,可以自己定义对象与对象的相减规则
    # 该方法返回一个新的对象
    return self.age - other.age
  
  def __iter__(self):
    # 实现对象可迭代，可以用for循环遍历对象
    # 该方法返回一个迭代器对象
    return iter([self.name, self.age])

# 创建对象
p = Person("Alice", 25)

# 打印对象
print(p)

# 调用__repr__方法
print(repr(p))

# 调用__delitem__方法
# del p.name
# 再次打印对象  
# print(p) 'Person' object has no attribute 'name'

# 调用__add__方法
p2 = Person("Bob", 30)
p3 = p + p2#这里的+号调用的是__add__方法
print(p3)

# 调用__sub__方法
print(p2 - p)

# 调用__iter__方法
print(type(p))
for item in p:
  print(item)

11.比较常用的魔术方法

class Images:

  def __init__(self,path):
    self.path = path
    self.arr = ["6.jpg","5.jpg","4.jpg","3.jpg","2.jpg","1.jpg"]

  def __len__(self):
    return len(self.arr)#由自己决定的返回

  def __getitem__(self,index):
    print(index)
    return self.arr[index]#利用传入的下标进行操作
  
  def __setitem__(self,index,value):
    print(index,value)

  def __call__(self, *args, **kwargs):
    print("调用了__call__方法",args,kwargs)

  
  
  
imgs = Images("./imgs")
count = len(imgs)
print(count)#自动调用__len__

# 调用__getitem__
# print(imgs[100]) 报错，arr越界了
print(imgs[2])

# 调用__setitem__
print("===========")
imgs[1] = 2
print("===========")
print("__setitem__",imgs[1])

# 调用__call__
imgs(1,2,3,a=1,b=2)

12.继承

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print(f"{self.name}今年{self.age}岁，正在吃饭")
  
p1 = Person("张三", 20)
p1.eat()

class Student(Person):
    # 子类构造函数中必须调用父类构造函数
    # 否则无法调用父类属性
    def __init__(self, name, age, school):
        # 调用父类构造函数
        # 必须在子类构造函数的第一行调用
        super().__init__(name, age)
        self.school = school

s1 = Student("李四", 21, "清华大学")
s1.eat()
print(s1.school)

运行结果：

张三今年20岁，正在吃饭
李四今年21岁，正在吃饭
清华大学

13.覆盖-重写

父类已经定义了一个方法，子类要将这个方法重新修改，就叫重写

class Animal:
  def __init__(self,name):
    self.name = name
  
  def eat(self):
    print("Animal的eat方法，{} is eating".format(self.name))

  def sleep(self):
    print("Animal的sleep方法，{} is sleeping".format(self.name))

class Dog(Animal):
  def __init__(self, name,age):
    super().__init__(name)
    self.age = age

  def say(self):
    print("Dog的say方法，{} is barking".format(self.name))

  def eat(self):
    print("Dog重写了Animal的eat方法，{} is eating".format(self.name))

dog = Dog("旺财", 3)
print(dog.name)
print(dog.age)
dog.sleep()
dog.say()
dog.eat()

14.多台

class Animal:
    def eat(self):
        print("动物会吃东西")

class Dog(Animal):
    def eat(self):
        print("狗会吃骨头")

class Cat(Animal):
    def eat(self):
        print("猫会吃鱼")

def eat(animal):
    animal.eat()# 体现了多态

dog = Dog()
cat = Cat()

eat(dog) 
eat(cat)

# 看dog是否是Dog或他的父类的实例
print(isinstance(dog, Animal))
print(isinstance(dog, Dog))

15.私有属性

不同于类属性，在属性前面加__表示只能在类中调用这个属性

class Person:
    __name = 'jack'
    def __init__(self, __age):
        self.__age = __age
    def fn(self):
        print("私有属性只能在类内部访问")
        print("私有属性：", self.__name)
        print("私有属性：", self.__age)

p = Person(25)
# print(p.__name)  # 报错
# print(p.__age)  # 报错
p.fn()  # 通过实例化对象调用私有方法，可以在类内部访问私有属性和方法

16.重载魔术方法

下面重新定义了Python中的加减乘除，实质就是改写了底层的魔术方法

class Box:
  def __init__(self, width, height):
    self.width = width
    self.height = height

  def __add__(self, other):
    return self.width + self.height + other.width + other.height
  
  def __sub__(self, other):
    return self.width - self.height - other.width - other.height
  
  def __mul__(self, other):
    return self.width * self.height * other.width * other.height
  
  def __truediv__(self, other):
    return self.width / self.height / other.width / other.height
  
  def __floordiv__(self, other):
    return self.width // self.height // other.width // other.height
  

b1 = Box(2, 3)
b2 = Box(4, 5)

print(b1 + b2)
print(b1 - b2)
print(b1 * b2)
print(b1 / b2)
print(b1 // b2)

17.super()方法

class Box:
  x = 5
  def fn(self):
      print("这是Box类的fn方法")

  def fm(self):
      print("这是Box类的fm方法")

class Box2(Box):
  # 重写父类的fn方法 
  x = 10
  def fn(self):
      super().fn()
      print("这是Box2类的fn方法")
      super().fm()
      print("这是Box2类的fm方法")

b = Box2()
b.x = 400
super(Box2, b).fn()  # 这是b对象调用父类的fn方法
# 总结：执行Box2父类的fn()函数 把b2作为第一个参数self传入进去
super(Box2, b).x

十六、迭代器和生成器

1.迭代器iter

全局函数iter 可以把一个可迭代对象转换成一个迭代器，全局函数next 他可以迭代下一次迭代器中的数据，for 循环可以连续调用next

arr = [10,20,30,40,50]
iterator = iter(arr)
re1 = next(iterator)
print(re1)

re2 = next(iterator)
print(re2)

re3 = next(iterator)
print(re3)

for el in iterator:
  # 接着re3迭代
  print(el,"====================")

# re4 = next(iterator)
# print(re4)#报错，re3已经迭代完了

案例：

实现数据加载器的底层核心源代码，有一个数据容器，里面有1000条数据，封装一个可迭代对象，这个对象迭代一次就取出这个列表的n条数据，n = 8

class myData:
    def __init__(self,data):
        self.data = data
        self.index = -1
    def __iter__(self):
        return self
    def __next__(self):
        while self.index < len(self.data)//8:
          self.index += 1
          return self.data[self.index * 8:(self.index+1) * 8]

data = myData(["a", "b", "c", "d", "e", "f", "g", 
        "h", "i", "j", "k", "l", "m", "n",
        "o", "p", "q", "r", "s", "t", "u", 
        "v", "w", "x", "y", "z"])


data_loader = iter(data)
re = next(data_loader)
print(re)
re = next(data_loader)
print(re)
re = next(data_loader)
print(re)

2.生成器yield

yield关键字在函数内部 会让函数暂时生成结果，但是函数还没有运行完毕，并且这个函数调用的代码的后面的代码会正常执行

def my_gen():
    print("start")
    yield 1
    print("middle")
    yield 2
    print("end")
    yield 3

re = my_gen()
print(next(re),"===========") 
# re = my_gen()
print(next(re),"===========")
# re = my_gen()
print(next(re),"===========")
# 结束迭代
# re = my_gen()
# print(next(re),"===========")

案例：

实现range函数源代码

def myrange(start,end,step):
    i = start - step
    while True:
      i += step
      if i >= end:
        # raise StopIteration
        break
      yield i

for el in myrange(0,11,2):
   print(el)

十七、异常处理

try:
    arr = [100,20]
    x = arr[100]
    print(x)

except ValueError:
    print("数组类型错误",ValueError)

except IndexError as e:
    print("数组越界",e)

else:
    print("没有异常")

finally:
    print("不管有没有报错都执行finally")

print("后面的代码")

运行结果：

数组越界 list index out of range
不管有没有报错都执行finally
后面的代码

常见的几种except选项：

| ZeroDivisionError | 除(或取模)零 (所有数据类型)  |
| ----------------- | ---------------------------- |
| ValueError        | 传入无效的参数               |
| AssertionError    | 断言语句失败                 |
| StopIteration     | 迭代器没有更多的值           |
| IndexError        | 序列中没有此索引(index)      |
| IndentationError  | 缩进错误                     |
| OSError           | 输入/输出操作失败            |
| ImportError       | 导入模块/对象失败            |
| NameError         | 未声明/初始化对象 (没有属性) |
| AttributeError    | 对象没有这个属性             |

或者直接不写这个错误类型

try:
    print(3 / 0)
except:
    print("报错")
else:
    print("没错")

运行结果：

报错

主动抛出错误：

def fn():
    x = 10
    if 5<x<6:
        print(x)
    else:
        raise ValueError("x不在范围内")
try:
    fn()
except ValueError as e:
    print(e)
print("后续代码")

运行结果：

x不在范围内
后续代码

十八、模块与包

import model1 as m1
from model2 import area
from model2 import perimeter as peri

print(m1.is_prime(7))
print(m1.is_palindrome("racecar"))

print(area(5, 6))
print(peri(5, 6))

1. file__和__name

这两个全局变量保存的是字符串

print(__file__)# 保存的是当前文件路径
print(__name__)# 保存当前模块名
# 当运行这个Python文件，如果是入口程序

运行结果：

d:\桌面\华清\基础语法\code\Python基础语法\21-模块与包.py
main

十九、内置函数

import random
import time
import os
if __name__ != "__main__":
    # 随机数
    # random.seed(42)
    re1 = random.random()
    print("re1",re1)
    # 随机整数
    re2 = random.randint(-5,6)
    print("re2",re2)
    # 随机取出
    arr = [1,2,3,4,5,6,7,8,9]
    re3 = random.choice(arr)
    print("re3",re3)
    # 打乱列表
    re4 = random.shuffle(arr)
    print("re4",re4)#返回None
    print(arr)

    # time 模块
    def time_fn():
        t = time.time()
        print(t)

    for i in range(3):
        time_fn()
        time.sleep(1)#每次循环时间间隔5秒
        print(time.localtime())#获取时间信息
        print(time.localtime().tm_mday)#具体到某一项
        print(time.strftime("%y年%m-%d %H:%M:%S"))#格式化时间格式

# os 模块用于操作计算机的一些东西
def os_fn():
    path = os.getcwd()#获取当前文件夹地址
    print(f"====={path}=======")
    # 绝对路径
    re = os.path.join(path,"./img","a.jpg")
    print(re)
    # 相对路径
    re1 = os.path.realpath(re)
    print(re1)
    # 创建文件夹
    os.mkdir("./code/img")


if __name__ == "__main__":
    # os模块
    os_fn()


    

总结

大纲已完结，后续会有补充