《Python系列》Python详细入门教程_python教程

文章目录

• Python详细入门教程
• • 第一章：
  • • 1.常见输出：
    • 2.转义字符
  • 第二章：
  • • 1.注释
    • 2.标识符
    • 3.变量
    • 4.数据类型
    • 5.字符编码
  • 第三章
  • • 1.基础运算符
    • 2.比较运算符
    • 3.赋值运算符
    • 4.布尔运算符
    • 5.位运算符
    • 6.输入函数
  • 第四章
  • • 1.顺序结构
    • 2.选择结构-单分支
    • 3.选择结构-双分支
    • 4.选择结构-多分支
    • 5.选择结构-嵌套循环
    • 6.循环结构
    • 7.break语句
    • 8.continue语句
    • 9.pass语句
    • 10.range函数
    • 11.对象的布尔值
  • 第五章
  • • 1.集合
    • 2.列表
    • 3.元组
    • 4.字典
    • 5.生成式
    • 6.总结
  • 第六章
  • • 1.字符串常用操作
    • 2.字符串比较操作
    • 3.字符串切片操作
    • 4.字符串编码解码
    • 5.字符串驻留机制
    • 6.格式化字符串
  • 第七章
  • • 1.函数
    • 2.函数返回值
    • 3.函数默认值
    • 4.位置参数和关键字参数
    • 5.参数总结
    • 6.变量的作用域
    • 7.递归函数
    • 8.斐波那契
  • 第八章
  • • 1.bug
    • 2.Python常见的异常类型
    • 3.异常处理机制
    • 4.TraceBack模块的使用
  • 第九章
  • • 1.两大编程思想
    • 2.类和对象的理解
    • 3.类和对象的创建
    • 4.类属性-类方法-静态方法
    • 5.动态绑定属性和方法
  • 第十章
  • • 1.继承
    • 2.封装
    • 3.多态
    • 4.方法重写
    • 5.特殊属性
    • 6.特殊方法
    • 7.Object
    • 8.类的浅拷贝和深拷贝
  • 第十一章
  • • 1.主程序
    • 2.包
    • 3.模块
    • 4.Python内置模块
    • 5.第三方模块的安装和使用
    • 6.导入注意事项
  • 第十二章
  • • 1.文件的读写原理
    • 2.文件对象的常用方法
    • 3.常见文件打开方法
    • 4.OS
    • 5.with语句
    • 6.编码格式
• Python十四案例
• • 1.ASCII码
  • 2.enumerate函数
  • 3.wordcount
  • 4.修改字体输出颜色
  • 5.列表倒叙输出
  • 6.十进制转二八十六
  • 7.向文件输入语句
  • 8.字符串分割
  • 9.异常抛出
  • 10.格式化字符串输出
  • 11.格式化时间类型
  • 12.登录支付功能
  • 13.遍历两个列表输出
  • 14.列表

Python详细入门教程

第一章：

1.常见输出：

# Author : zxy
# Date : 2022/5/2 11:50
# 1.输出数字
print(520)
# 2.输出字符串1
print('hello world')
# 2.输出字符串2
print("hello world")
# 3.输出结果到文件
# 不存在即创建 存在即追加
fp = open('F:/text.txt','a+')
print('hello world',file=fp)
fp.close()
# 4.不换行输出
print('hello','world','python')


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.转义字符

# Author : zxy
# Date : 2022/5/2 12:12

# 转义字符-换行
print('hello\nworld')

# 转义字符-table键
print('hello\tpython')

# 转义字符-backspace
print('hello\bzxy')

# 转移字符-return
print('hello\rworld')

# 转义字符-\" \'
print("\"hello\"","\'world\'")

# 转义字符-\\
print("http:\\\\www.baidu.com")

# 原字符-不希望字符串中的转义字符起作用，就使用原字符，就是在字符串前加上r或者R
print(r"http:\\www.baidu.com")
# 原字符使用-末尾不能使用一个反斜杠结尾会报错，需要的话，使用两个
# print(r"http:\\www.baidu.com\")
print(r"http:\\www.baidu.com","\b\\")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

第二章：

1.注释

# coding:utf-8
# Author : zxy
# Date : 2022/5/2 19:09

# Python代码中的注释
# 注释：
#   提高代码可读性
#   注释内容会被Python解释器忽略
#   三种注释类型：
#       单行注释：以#开头
"""
多行注释：将一对三引号之间代码称为多行注释
"""
#       中文编码声明注释：文件开头加上中文声明注释，用以指定源码文件的编码格式


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.标识符

# Author : zxy
# Date : 2022/5/2 15:07

import keyword

# 查看所有保留字
print(keyword.kwlist)

# 标识符规则
# 变量、函数、类、模块和其他对象起的名字就叫标识符
# 规则：
#   1.字母、数字、下划线
#   2.不能以数字开头
#   3.不能是保留字
#   4.严格区分大小写


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3.变量

# Author : zxy
# Date : 2022/5/2 15:13

name = 'zxy'
print(name)
print('标识',id(name))
print('类型',type(name))
print('值',name)

# 再次赋值后，会开辟新的内存空间
name = 'python'
print(name)


1
2
3
4
5
6
7
8
9
10
11
12
13
14

4.数据类型

# Author : zxy
# Date : 2022/5/2 18:22
from decimal import Decimal
# 数据类型
# 1.整数类型 int
#   1.1 可以表示正数、负数、0
n1 = 100
n2 = -100
n3 = 0
print(n1,type(n1))
print(n2,type(n2))
print(n3,type(n3))
#   1.2 整数可以表示 为二进制 十进制 八进制 十六进制
#   1.2.1 二进制取值[0,1]，逢2进一
print('二进制',0b10101111)
#   1.2.2 十进制取值[0,1,2,3,4,5,6,7,8,9] 逢10进一
print('十进制',118)
#   1.2.3 八进制取值[0,1,2,3,4,5,6,7] 逢8进一
print('八进制',0o176)
#   1.2.4 十六进制取值[0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F] 逢16进一
print('十六进制',0x1EAF)
# 2.浮点数类型 float
f1 = 1.1
f2 = 2.2
#   输出结果3.3000000000000003，因为是通过二进制计算，存在浮点数小数点不准确性
print(f1,type(f1))
print(f1 + f2)
print(Decimal('1.1') + Decimal('2.2'))
# 3.布尔类型 bool
#   3.1 布尔判断
b1 = False
b2 = True
print(b1,type(b1))
if(b1) :
  print('true')
else :
  print('false')
#   3.2布尔相加
print(b1 + 1) # b1为false相当于0
print(b2 + 0) # b2为true相当于1
# 4.字符串类型 str
#   4.1 单引号，必须在一行
print('hello world',type('hello world'))
#   4.2 双引号，必须在一行
print("hello world",type("hello world"))
#   4.3 三引号，可以不在一行
print("""
        hello 
        world
        python
    """)
# 4.不同数据类型连接,使用str将int类型转成string类型
print('------------------------str()转换类型--------------------------')
name = '张三'
age = 28
print('我是'+name+',我今年'+str(age)+'岁了')
print('------------------------int()转换类型--------------------------')
s1 = '128'
s2 = True
s3 = 98.8
s4 = '98.8'
s5 = 'hello'
print(s1,type(s1),int(s1),type(int(s1)))
print(s2,type(s2),int(s2),type(int(s2)))
# float转成int，会将小数截取掉
# 将s4转成Int类型会报错，因为字符串为小数串
# 将s5转成int类型也会报错，因为字符串转成整数，该字符串必须为整数数字串
print(s3,type(s3),int(s3),type(int(s3)))

print('------------------------float()转换类型--------------------------')
s1 = '98.8'
s2 = '98'
s3 = True
s4 = 98
s5 = 'hello'
# 将s5转成float类型会失败，只允许为数字串(整数，浮点数)
print(s1,type(s1),float(s1),type(float(s1)))
print(s2,type(s2),float(s2),type(float(s2)))
print(s3,type(s3),float(s3),type(float(s3)))
print(s4,type(s4),float(s4),type(float(s4)))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

5.字符编码

# Author : zxy
# Date : 2022/5/2 14:26

# 十进制
print(ord('乘'))

# 二进制
print(chr(0b100111001011000))

1
2
3
4
5
6
7
8
9

第三章

1.基础运算符

# Author : zxy
# Date : 2022/5/2 19:51

# 算术运算符 -> 位运算符 -> 比较运算符 -> 布尔运算符 -> 赋值运算符
# ** -> [*,/,//,%] -> [<<,>>] -> [&] -> [|] -> [>,<,<=,>=,==,!=] -> and -> or -> =

# 基础运算符
print(1+1) # 加法运算
print(1-1) # 减法运算
print(1*2) # 乘法运算
print(1/2) # 除法运算
print(11//2) # 整除运算符
print(11%2) # 取余运算符
print(2**2) # 2的2次方


print(9//4) # 2
print(-9//-4) # 2

# 一正一负取整
print(9//-4) # -3 向下取整
print(-9//4) # -3 向下取整

# 一正一负，取余
print(9%-4) # 商-3 公式：余数 = 被除数 - 除数 * 商  9 - (-4) * (-3) = 9 - 12 = -3
print(-9%4) # 商-3 公式：余数 = 被除数 - 除数 * 商  -9 - 4 * (-3) = -9 + 12 = 3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

2.比较运算符

# Author : zxy
# Date : 2022/5/2 20:25
# 比较运算符
a,b = 10,20
print('a>b？',a>b)
print('a<b?',a<b)
print('a>=b？',a>=b)
print('a<=b?',a<=b)
print('a==b？',a==b)
print('a!=b？',a!=b)
"""
    赋值运算符 =
    比较运算符 ==
    一个变量由三个部分组成，标识，类型，值
    == 比较的是值
    is 比较的是标识
"""
print('----------整数对比----------')
a = 10
b = 10
print('值比较',a == b)
print('id标识比较',a is b)
print('id标识比较',a is not b)
print('---------数组对比,值相同，id标识不同-----------')
a = [1,2,3,4]
b = [1,2,3,4]
print('值比较',a == b)
print('id标识比较',a is b)
print('id标识比较',a is not b)



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

3.赋值运算符

# Author : zxy
# Date : 2022/5/2 20:10

# 赋值运算符
# 执行顺序 ： 从右至左
a = 1 + 2
print('从右至左，先执行加法再赋值',a)
# 支持链式赋值,执行同一空间 ：a = b = c = 10
a = b = c = 10
print(a,id(a))
print(b,id(b))
print(c,id(c))
# 支持参数赋值 ：+= =+ *= /= //= %=
a = 20
a += 30
print('-------------a+=30 类似于 a = a + 30------------------')
print(a)
# 支持系列解包赋值 ： a,b,c = 20,30,40
print('-------------解包赋值------------')
a,b = 20,30
print(a,id(a))
print(b,id(b))
print('----------交换----------------')
a,b = b,a
print(a,id(a))
print(b,id(b))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

4.布尔运算符

# Author : zxy
# Date : 2022/5/2 21:12

# 布尔运算符 and or not in not in
a,b = 10,20
# and 全真为真 一假为假
print(a==10 and b == 10)
# or 全假为假 一真为真
print(a==10 or b==10)
# not 取反
b1 = True
print(not b1)
# in
s1 = 'helloworld'
print('w' in s1)
print('z' in s1)
# not in
s1 = 'helloworld'
print('w' not in s1)
print('z' not in s1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

5.位运算符

# Author : zxy
# Date : 2022/5/2 21:44
# 位运算符 & | << >>

# 与运算符 & 同1为1 否则为0
# 0100
# 1000
# &
# 0000
print(4&8)

# 或运算符 | 同0为0 否则为1
# 0100
# 1000
# |
# 1100
print(4|8)

# 逻辑右移 >>
# 0100 => 4
# >> 1
# 0010 => 2
print(4>>1)

# 逻辑左移
# 0100 => 4
# << 1
# 1000 => 8
print(4<<1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

6.输入函数

# Author : zxy
# Date : 2022/5/2 19:42

# input输入函数
name = input('请输入你的名字：')
print(name,type(name))
# 转成int类型方式一
age = input('请输入你的年龄：')
print(age,type(age),int(age),type(int(age)))
# 转成int类型方式二
age = int(input('请输入你的年龄：'))
print(age,type(age))

1
2
3
4
5
6
7
8
9
10
11
12
13

第四章

1.顺序结构

# Author : zxy
# Date : 2022/5/2 22:21

# 顺序结构，把大象装冰箱
print('---------------程序开始--------------')
print('---------------1.打开冰箱--------------')
print('---------------2.大象放冰箱--------------')
print('---------------3.关冰箱门--------------')
print('---------------程序结束--------------')


1
2
3
4
5
6
7
8
9
10
11

2.选择结构-单分支

# Author : zxy
# Date : 2022/5/2 22:21

# 1.选择结构-单分支结构  银行取款

money = 1000

s = int(input('请输入取款金额：'))

if(money >= s):
    money -= s
    print('取款成功，剩余金额为：',money)

1
2
3
4
5
6
7
8
9
10
11
12
13

3.选择结构-双分支

# Author : zxy
# Date : 2022/5/3 10:31
# 2.选择结构-双分支结构 奇偶判断

i = int(input('请输入一个数字:'))

if i % 2 == 0:
    print('你输入一个偶数！')
else:
    print('你输入一个奇数！')

1
2
3
4
5
6
7
8
9
10
11

4.选择结构-多分支

# Author : zxy
# Date : 2022/5/3 10:31

# 3.选择结构-多分支结构 成绩等级划分

score = int(input('请输入一个成绩:'))

# if score >= 90 and score <= 100:
if 90 <= score <=  100:
    print('A级')
elif score >= 80 and score < 90:
    print('B级')
elif score >= 70 and score < 80:
    print('C级')
elif score >= 60 and score < 70:
    print('D级')
else:
    print('不及格')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

5.选择结构-嵌套循环

# Author : zxy
# Date : 2022/5/3 10:31
# 4.选择结构-嵌套结构 商场购物
money = int(input('请输入你需要支付金额！'))
vip = bool(input('请输入你是否是会员？True/False'))
if vip:
    if money >= 200:
        print('你需要支付：',money * 0.8)
    elif money >= 100:
        print('你需要支付：',money * 0.9)
    else:
        print('你需要支付：',money)
else:
    if money >= 200:
        print('你需要支付：',money * 0.95)
    else:
        print('你需要支付：',money)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

6.循环结构

# Author : zxy
# Date : 2022/5/2 22:21

"""
    循环结构
    while
    for - in
"""
def test1():
    a = 1
    while a < 10:
        print(a)
        a += 1
# 计算0到10的累加
def sum():
    '''初始化变量'''
    sum = 0
    a = 0
    '''条件判断'''
    while a <= 10:
        '''条件执行体'''
        sum += a
        a += 1
    print(sum)
# 1到100偶数和
def number():
    sum = 0
    i = 0
    while i <= 100:
        if i % 2 == 0:
            sum += i
        i+=1
    print('while计算求和',sum)
def number2():
    sum = 0
    for item in range(1,101):
        if item % 2 == 0:
            sum += item
    print('for-in计算求和:',sum)

# 100 到 1000 的水仙花
def water():
    for item in range(100,1001):
        ge = item % 10
        shi = item // 10 % 10
        bai = item // 100
        if ge**3+shi**3+bai**3 == item:
            print(item)

if __name__ == '__main__':
    number()
    number2()
    water()
    '''for-in'''
    for item in 'python':
        print(item)
    for i in range(10):
        print(i)
    for _ in range(1,3):
        print('hello python')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

7.break语句

# Author : zxy
# Date : 2022/5/3 13:30
# 通过break退出循环
'''密码三次输入不成功退出，密码正确退出'''
for item in range(3):
    pwd = input('请输入密码：')
    if pwd == '8888':
        print('密码正确')
        break
    else :
        print('密码不正确')
else:
    print('三次密码均失败！')

1
2
3
4
5
6
7
8
9
10
11
12
13
14

8.continue语句

# Author : zxy
# Date : 2022/5/3 13:34

'''break是退出循环'''
'''continue是退出当前循环，继续下一个循环'''

'''1到50之间，5的倍数'''
for item in range(1,51):
    '''如果item不是5的倍数，就跳出当前循环，继续下一个循环'''
    if item % 5 != 0:
        continue
    print(item)


1
2
3
4
5
6
7
8
9
10
11
12
13
14

9.pass语句

# Author : zxy
# Date : 2022/5/3 10:44
# pass语句，什么都不做，只是一个占位符，用到需要写语句的地方
money = int(input('请输入你需要支付金额！'))
if money >= 200:
    pass
    # 当没想好怎么写的时候，可以先使用pass占位，继续写后面的操作
    # print('你需要支付：', money * 0.8)
elif money >= 100:
    print('你需要支付：', money * 0.9)
else:
    print('你需要支付：', money)

1
2
3
4
5
6
7
8
9
10
11
12
13

10.range函数

# Author : zxy
# Date : 2022/5/3 10:50

# range函数
'''一个参数，表示从0到10'''
n1 = range(10)
print(list(n1))

'''两个参数，从1开始到19'''
n2 = range(1,19)
print(list(n2))

'''三个参数，从1开始到19，步长为2'''
n3 = range(1,19,2)
print(list(n3))

'''判断指定的整数 在序列中是否存在 in，not in '''
print(10 in n3)
print(10 not in n3)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

11.对象的布尔值

# Author : zxy
# Date : 2022/5/2 22:36
"""
Python所有对象都有一个布尔值
   获取对象的布尔值，使用内置函数bool()
   以下对象的布尔值为False
       False
       数值0
       None
       空字符串
       空列表
       空元组
       空字典
       空集合
"""
print(bool(False)) #  False
print(bool(0.0)) # 数值0
print(bool(None)) # None
print(bool('')) # 空字符串
print(bool("")) # 空字符串
print(bool([])) # 空列表
print(bool(list())) # 空列表
print(bool(())) # 空元组
print(bool(tuple())) # 空元组
print(bool({})) # 空字典
print(bool(dict())) # 空字典
print(bool(set())) # 空集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

第五章

1.集合

# Author : zxy
# Date : 2022/5/3 22:41

# 集合
"""
集合：
    Python语言提供的内置数据结构
    与列表、字典一样都属于可变类型的序列
    集合是没有value的字典
"""

# 1.集合的创建
"""
集合的创建方式：
    直接{}
        s = {'python','java'}
    使用内置函数set()
        s = set(range(6))
        s = set([1,2,3,4])
        s = set((1,2,3,4))
        s = set('python')
        s = set({1,2,3,4})
        s = set()
"""

def create_tuple():
    s = {'python', 'java','java'} # 集合中元素不能重复，会把重复的元素自动去掉
    print(s,type(s))
    s = set(range(6))
    print(s, type(s))
    s = set([5, 2, 3, 4]) # 集合中元素是无序的
    print(s, type(s))
    s = set((1, 6, 3, 4))
    print(s, type(s))
    s = set('python')
    print(s, type(s))
    s = set({1, 2, -1, 4})
    print(s, type(s))
    s = set() # 空集合
    print(s, type(s))
    s = {} # 空字典
    print(s, type(s)) # 不能使用空的大括号创建集合，因为这默认是字典

# 2. 集合相关操作
"""
集合元素的判断
    in 
    not in 
集合元素的新增：
    add() ,一次添加一个元素
    update()至少添加一个元素
集合元素的删除：
    remove() ,一次删除一个指定元素，如果指定元素不存在抛出异常KeyError
    discord(),一次删除指定元素，如果指定元素不存在不抛出异常
    调用pop(),一次只删除一个任意元素
    调用clear() ，情况集合
"""
def opter_set():
    s = {'hello','my','python','time'}
    print('python是否在集合中？','python' in s)
    print('python是否不在集合中？', 'python' not in s)

    s.add('java')
    print('add添加元素Java：',s)

    s.update('a','b','c')
    print('update添加元素a,b,c:',s)

    s.remove('java')
    print('指定删除Java元素：',s)
    # s.remove('zxy') remove删除一个不存在的元素，会抛出异常
    s.discard('zxy')
    print('discard删除不存在的元素，不会报错:',s)
    s.pop()
    print('pop删除任意一个元素：',s)
    s.clear()
    print('clear清空所有集合元素：',s)

# 3.集合的关系
"""
两个集合是否相等
    可以使用运算符==或!=判断
一个集合是否是另一个集合的子集
    可以调用方法issubset进行判断
    B是A的子集
一个集合是否另一个集合的超集
    可以调用方法issuperset进行判断
    A是B的超集
两个集合是否没有交集
    可以调用方法isdisjoint进行判断
"""
def relation_set():
    s1 = {10,20,30,40}
    s2 = {40,10,20,30}
    s3 = {10,20}
    s4 = {60,70}
    print('s1和s2相同？',s1==s2)
    print('s1和s2不相同',s1!=s2)
    print('s3是s1的子集？',s3.issubset(s1))
    print('s1是s3的超集',s1.issuperset(s3))
    print('s1和s4没有交集？',s1.isdisjoint(s4)) # 没有交集为True，有交集为False

# 4.集合的数据操作
"""
    交集
    并集
    差级
"""
def data_opetate():
    s1 = {10, 20, 'hello'}
    s2 = {40, 10, 20, 30}
    print('方式一：s1和s2交集：',s1.intersection(s2))  # 交集
    print('方式二：s1和s2交集：',s1 & s2)
    print('方式一：s1和s2并集：',s1.union(s2))  # 并集
    print('方式二：s1和s2并集：',s1 | s2)
    print('方式一：s1减去[s1和s2的交集]：',s1.difference(s2))  # 差集
    print('方式一：s2减去[s1和s2的交集]：',s2.difference(s1))
    print('方式二：s1减去[s1和s2的交集]：', s1 - s2)
    print('方式二：s2减去[s1和s2的交集]：', s2 - s1)
    print('s1和s2的并集减去s1和s2的交集：',s1.symmetric_difference(s2)) # 对称差集
# 5. 集合生成式
def create_set():
    s = { i for i in range(6)}
    print(s,type(s))
if __name__ == '__main__':
    create_set()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

2.列表

# Author : zxy
# Date : 2022/5/3 14:04

"""
列表：
    变量 可以存储一个元素，
        而列表是一个”大容器“可以存储N多个元素，
        程序可以方便的对这些数据进行整体操作
    列表相当于其他语言中的数组
特点：
    列表元素按顺序有序排序
    索引映射唯一一个数据
    列表可以存储重复数据
    任意数据类型混存
    根据需要动态分配和回收内存
"""
def test():
    lst = [98,98.8,'hello']
    print(lst,id(lst))
    print(lst,type(lst))
    print(lst)
    lst2 = list(lst)
    print(lst2,type(lst2))

    print(lst[0])
    print(lst2[0])

'''
元素位置索引
索引：
    正向 0 到 N
    逆向 -N 到 -1
'''
def index_test():
    lst = [98, 98.8, 'hello']
    print(lst.index(98))
    print(lst.index('hello',1,3))
"""
切片：
    获取列表中多个元素
切片的结果->原列表片段的拷贝
切片的范围->
"""
def split_test():
    lst = [10,20,30,40,50,60,70]
    print('原列表：',lst)
    print('起始位2，结束为6，步长为1：',lst[2:6:1])
    print('不设起始，结束为6，步长为2：',lst[:6:2])
    print('起始为2，不设结束，步长为1：',lst[2::1])
    print('不设起始，不设结束，步长为1',lst[::1])
    print('不设起始，不设结束，步长为-1,类似反转',lst[::-1])
"""
判断元素在列表中是否存在：
in 
not in
"""
def exists_test():
    lst = ['yyds','python','java']
    print('yyds' in lst)
    print('zxy' not in lst)
"""
    列表元素的遍历
"""
def list_test():
    lst = ['yyds', 'python', 'java']
    for ls in lst:
        print(ls)
"""
列表元素的增加操作
"""
def append_test():
    lst = ['yyds', 'python', 'java']
    lst2 = ['a','b','c']
    lst3 = [1,2,3]
    print('原数据',lst)
    lst.append('zxy')
    print('append追加后：',lst)
    lst.extend(lst2)
    print('extend追加多个元素：',lst)
    lst.insert(0,666)
    print('insert在索引为0的位置添加666：',lst)
    lst[1:]=lst3
    print('切片替换，从下标1开始的所有元素替换为lst3',lst)

def remove_test():
    lst = ['yyds', 'python', 'java','scala','html']
    print('原数据：',lst)
    lst.remove("yyds") # 从列表中移除一个元素，如果有重复元素，只移除第一个元素
    print('删除lst中指定元素',lst)
    lst.pop(0) # 通过指定索引，删除元素,如果不指定索引，则删除最后一个元素
    print('删除索引为0的数据：',lst)
    new_list = lst[1:3]
    print('切片删除，只留下索引1到3的数据，会产生新的列表对象：',new_list)
    lst[0:1] = []
    print('将列表中索引0到1的位置置空，相当于删除：',lst)
"""
修改列表元素
"""
def modify_test():
    lst = ['yyds', 'python', 'java', 'scala', 'html']
    print('原数据：', lst)
    lst[0] = 'bigdata'
    print('指定下标修改：',lst)
    lst[2:4] = [100,200,300,400]
    print('切片修改：',lst)
"""
排序查询
"""
def sort_test():
    lst = [40,10,30,90,100]
    print('原数据：',lst)
    lst.sort()
    print('不指定排序方式，默认升序排序：',lst)
    lst.sort(reverse=False)
    print('指定升序排序:', lst)
    lst.sort(reverse=True)
    print('指定降序排序：',lst)
    print('-------------------sorted()跟sort()的区别是，sort()是在原有list基础上排序，sorted()是生成新的列表-------------')
    lst = [40, 10, 30, 90, 100]
    print('原数据：', lst)
    new_list = sorted(lst)
    print('默认升序排序：',new_list)
    desc_list = sorted(lst,reverse=True)
    print('指定降序排序：',desc_list)
"""
列表生成式
"""
def create_test():
    lst = [i for i in range(1,10)]
    print(lst)
if __name__ == '__main__':
    create_test()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

3.元组

# Author : zxy
# Date : 2022/5/3 21:52

# 元组
"""
什么是元组？
    Python 内置的数据结构之以，是一个不可变序列
不可变序列与可变序列
    不可变序列：字符串、元组
        不可变序列没有增、删、改的操作
    可变序列：列表、字典
        可变序列：可以对序列执行增、删、改操作，对象地址不发生改变
"""

# 1.元组的创建
"""
    1.1 直接小括号
        t = ('python','java')
    1.2 使用内置函数tuple()
        t = tuple(('python','java'))
    1.3 只包含一个元组的元素需要使用逗号和小括号
        t = (10,)
"""
def create_tuple():
    # 空列表创建
    lst = []
    lst = list()
    # 空字典创建
    dic = {}
    dic = dict()
    # 空元组创建
    tup = ()
    tup = tuple()
    t = ('python','java')
    print(t,type(t))
    t = tuple(('python', 'java'))
    print(t, type(t))
    t = (10,)
    print(t, type(t))
    # 如果不加逗号，会被识别为int类型
    t = (10)
    print(t, type(t))

# 2.为什么要将元组设计成不可变序列
"""
为什么要将元组设计成不可变序列
    在多任务环境下，同时操作对象时不需要加锁
    因此，在程序中尽量使用不可变序列
注意事项：
    元组中存储的是对象的引用
    a) 如果元组中对象本身是不可变对象，则不能再引用其他对象
    b) 如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变
"""
def test():
    tup = (10,['a','b','c'],20)
    print(tup,'类型',type(tup))  # 元组类型
    print(tup[0],'类型',type(tup[0])) # 元组类型中的不可变对象
    print(tup[1],'类型',type(tup[1])) # 元组类型中的可变对象
    # tup[1]是list类型，可以增、删、改数据。但是不能将其改为tup[1]=100这种

# 3.元组的遍历
def list_tuple():
    print('--------------方式一：索引获取--------------------')
    tup = (10, ['a', 'b', 'c'], 20)
    print(tup[0])
    print(tup[1])
    # 但是这样的缺陷是，你要知道总共有多少数据
    print('--------------方式二：遍历查询----------------------')
    for item in tup:
        print(item)

# 主函数
if __name__ == '__main__':
    list_tuple()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

4.字典

# Author : zxy
# Date : 2022/5/3 16:47

"""
字典：
    1.什么是字典
    2.字典得原理
    3.字典的创建与删除
    4.字典的查询操作
    5.字典的增删改
    6.字典推导式
"""
# 1.什么是字典
"""
    以Python内置的数据结构之一，与列表一样是一个可变序列
    以键值对的方式存储数据，字典是一个无序的序列
    eg: scores = {'张三':100,'李四':99}
        字典名：scores
        花括号：{}
        键：'张三'
        值：100
        冒号：:
        逗号：,
"""

# 2.字典原理
"""
    
    字典的实现原理与查字典类似，查字典是先根据部首或拼音查找对应的页码，Python中的字典是根据Key查找Value所在位置
    
    字典元素的位置，不是按照输入的位置，是按照hash函数计算key的得到的
    key:不可变的序列
"""

# 3.字典的创建
def create_dict():
    list1 = ['张三','李四']
    list2 = [100,99]
    scores = {'张三':100,'李四':99}
    print('字典创建方式一：',scores)
    scores = dict(name='张三',age=18)
    print('字典创建方式二：',scores)
    scores = {list1:list2 for list1,list2 in zip(list1,list2)}
    print('字典创建方式三：',scores)

# 4.字典的查询
def get_dict():
    scores = {'张三': 100, '李四': 99}
    print('-----------------方式一和二的区别主要在于：方式一查找不存在的键会报错，方式二会返回一个None值')
    print('查找方式一',scores['张三'])
    print('查找方式二',scores.get('张三'))
    print('查找方式二,不存在的键：',scores.get('zxy'))
    print('查找方式二,不存在的键，修改默认返回值None：',scores.get('zxy',100))

# 5.字典的常用操作
"""
key的判断：in 或者 not in
字典的删除：del scores['张三']
字典的元素新增：scores['zxy']=100
"""
def operate_test():
# 判断是否存在
    scores = {'张三': 100, '李四': 99}
    print('判断张三是否存在：','张三' in scores)
    print('判断张三是否存在：', 'zxy' in scores)

# 删除元素
    del scores['张三']
    print("删除key='张三':",scores)

# 清空字典
    scores.clear()
    print('清空数据元素：',scores)

# 新增元素
    scores['zxy'] = 100
    print("增加key='zxy',value='100",scores)

# 修改元素
    scores['zxy'] = 99
    print('key是唯一的，如果重复新增，会覆盖原有值：',scores)

# 6.获取字典试图的三种方法
"""
    keys() 获取字典中所有key
    values() 获取字典中所有value
    items() 获取字典中所有key，value
"""
def view_test():
    scores = {'张三': 100, '李四': 99}
    keys = scores.keys()
    print('获取字典的所有key:',keys)
    values = scores.values()
    print('获取字典的所有value:',values)
    print('-----------------将key集合和list集合转成列表-----------------')
    print(list(keys),list(values))
    items = scores.items()
    print('获取字典中的所有key,value',items)
    print('--------------------将items转成元组tuple集合--------------')
    print(tuple(items))
# 7.循环字典元素
def list_dict():
    scores = {'张三': 100, '李四': 99}
    for item in scores:
        print('key=',item,'value=',scores[item])
        print('key=',item,'value=',scores.get(item))

# 8.字典的特点
"""
字典的特点：
    字典中所有元素都是一个key-value键值对，key不允许重复，value可以重复
    字典中的元素是无序的
    字典中的key必须是不可变对象
    字典也可以根据需要动态的伸缩
    字典会浪费较大的内存，是一种使用空间换时间的数据结构   *********************
"""

# 9.字典生成式
"""
内置函数zip()
    用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，
    然后返回由这些元组组成的列表
"""
def zip_dict():
    lst1 = ['张三','李四','王五']
    lst2 = [100,20,50]

    # 使用zip将两个列表，压缩成一个元组组成的列表
    dic1 = zip(lst1,lst2)
    print(list(dic1),type(dic1))

    # 使用zip元素，将两个元组，组成一个字典
    dic2 = {lst1:lst2 for lst1,lst2 in zip(lst1,lst2) }
    print(dic2,type(dic2))


# 主函数
if __name__ == '__main__':
    zip_dict()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

5.生成式

# Author : zxy
# Date : 2022/5/4 10:27


# 列表生成式
list1 = [ i for i in range(6)]
print(list1,type(list1))

# 集合生成式
set1 = { i for i in range(6)}
print(set1,type(set1))

# 字典生成式
k = ['张三','李四']
v = [100,90]
dict1 = {k:v for k,v in zip(k,v)}
print(dict1,type(dict1))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

6.总结

# Author : zxy
# Date : 2022/5/4 10:30

# 总结

"""
共有列表、字典、元组、集合
列表  []
字典  {key:value}
元组 ()
集合 {}
其中：
    列表、字典、集合都是可变的，元组不可变
    列表、元组可以有重复，集合不可以重复，字典的key不可以重复，value可以重复
    列表、元组是有序的，字典、集合是无序的

"""

# 1.元组
"""
创建元组：
    使用小括号()创建
    使用内置函数tuple()创建
元组遍历：
    for ... in 
不可变序列
"""

# 2.集合
"""
创建集合
    使用花括号{}
    内置函数set()
    集合生成式
集合遍历
    for ... in 
新增
    add()
    update()
删除
    remove()
    discard()
    pop()
    clear()
可变序列
"""

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

第六章

1.字符串常用操作

# Author : zxy
# Date : 2022/5/4 13:45

# 查询操作
"""
index() 查找字符第一次出现的位置，不存在抛出异常ValueError
rindex() 查找字符最后一次出现的位置，不存在抛出异常ValueError
find() 查找字符第一次出现的位置，不存在返回-1
rfind() 查找字符最后一次出现的位置，不存在返回-1
"""

def find_str():
    s = 'password'
    i = s.index('s')
    print('index查找字符第一次出现的位置，不存在抛出ValueError',i)
    i = s.find('s')
    print('index查找字符第一次出现的位置，不存在返回-1',i)
    i = s.find('z')
    print('index查找字符第一次出现的位置，不存在返回-1', i)
    j = s.rindex('s')
    print('index查找字符最后一次出现的位置，不存在抛出ValueError', j)
    j = s.rfind('s')
    print('index查找字符最后一次出现的位置，不存在返回-1', j)
    j = s.rfind('z')
    print('index查找字符最后一次出现的位置，不存在返回-1', j)

# 2. 字符串带小写转换
"""
upper() 把字符中的所有字符串都转成大写字母
lower() 把字符中的所有字符串都转成小写字母
swapcase() 把字符串中所有大写字母都转成小写字母，把所有小写字母转成大写字母
capitalize() 把第一个字符转成大写，其他转成小写
title() 把每个单词第一个字符转成大写，其余转成小写
"""
def trans_str():
    s = 'hEllo wOrd'
    print('原数据',s)
    print('upper():',s.upper())
    print('lower()',s.lower())
    print('swapcase()',s.swapcase())
    print('captitalize()',s.capitalize())
    print('title()',s.title())

# 3.字符串对齐方式
def align_str():
    s = 'hello word'
    print('居中对齐:',s.center(20,'-'))
    print('左对齐:',s.ljust(20,'_'))
    print('右对齐:',s.rjust(20,'_'))
    print('右对齐，只传一个参数，默认0填充',s.zfill(20))

# 4.字符串拆分
def split_str():
    s1 = 'hello world python'
    s2 = 'hello-world-python'
    print('从左往右分'.center(100,'*'))
    print('split默认按空格拆分',s1.split())
    print('split,设置sep选择分隔符，设置maxsplit设置最大分割次数', s2.split(sep='-',maxsplit=1))
    print('\n')
    print('从右往左分'.center(100, '*'))
    print('rsplit默认按空格拆分',s1.rsplit())
    print('rsplit,设置sep选择分隔符，设置maxsplit设置最大分割次数', s2.rsplit(sep='-', maxsplit=1))
    """从左往右和从右往左分的最主要的区别在与设置maxsplit后，会得到不同的结果"""

# 5. 字符串判断操作
"""
isidentifier()  是不是合法的标识符
isspace() 是否全部由空白字符串组成(回车、换行、水平制表符)
isalpha() 是否全部由字母组成
isdecimal() 是否全部由二进制数字组成
isnumeric() 是否全部由数字组成 
isalnum() 是否全部由字母和数字组成
"""
def judge_str():
    s1 = 'hello_123'
    s2 = s1.join('@')
    s3 = '      \t'
    s4 = 'abcd'
    s5 = '1234'
    s6 = '123四'
    print('合法标识符'.center(70,'*'))
    print(s1,'是不是由合法标识符组成',s1.isidentifier())
    print(s1,'是不是由合法标识符组成',s2.isidentifier())

    print('\n','空白字符串'.center(70, '*'))
    print(s1, '是不是空白字符串组成', s1.isspace())
    print(s3,'是不是空白字符串组成',s3.isspace())

    print('\n', '字母'.center(70, '*'))
    print(s1,'是不是全部由字母组成',s1.isalpha())
    print(s4, '是不是全部由字母组成', s4.isalpha())

    print('\n', '十进制数字'.center(70, '*'))
    print(s5,'是不是由十进制数字组成',s5.isdecimal())
    print(s6, '是不是由十进制数字组成', s6.isdecimal())

    print('\n', '数字'.center(70, '*'))
    print(s5, '是不是由数字组成', s5.isnumeric())
    print(s6, '是不是由数字组成', s6.isnumeric())

    print('\n', '字母和数字'.center(70, '*'))
    print(s1, '是不是全由字母和数字组成', s1.isalnum())
    print(s4,'是不是全由字母和数字组成',s4.isalnum())

# 6.字符串替换和 合并
def replace_join_str():
    s1 = 'hello java java'
    lst = ['hello','java','python']
    tup = ('hello','java','python')
    print('replace替换',s1.replace('java','python'))
    print('replace只替换1个目标',s1.replace('java','python',1))
    print('join合并','*'.join(s1))
    print('列表合并','*'.join(lst))
    print('元组合并','*'.join(tup))
if __name__ == '__main__':
    replace_join_str()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

2.字符串比较操作

# Author : zxy
# Date : 2022/5/4 15:31

# 字符比较操作
"""
字符串的比较操作：
    运算符：> >= < <= == !=
比较规则：
    首先是比较两个字符串中第一个字符，如果相等则继续比较下一个字符，
    依次比较下去，直到两个字符串中的字符不相等时，其比较结果就说两个字符串的比较结果
    两个字符串中的所有后续字符将不再被比较
比较原理：
    两个字符进行比较时，比较是其ordinal value（原始值），调用内置函数ord可以 得到指定字符的Ordinal value。
    与内置函数ord对应的内置函数是chr,调用内置函数chr时指定ordinal value可以得到其对应的字符
"""
def compare_str():
    print('python' > 'java')
    print('p',ord('p'))
    print('j',ord('j'))

    print('112',chr(112))
    print('106',chr(106))

    ## == 比较的值
    ## is 比较的id
if __name__ == '__main__':
    compare_str()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

3.字符串切片操作

# Author : zxy
# Date : 2022/5/4 16:05

# 字符串切片操作
"""
字符串是不可变类型
    不具备增、删、改等操作
    切片操作将产生新的对象
"""
s = 'abcdefg'
print('指定切片区间',s[0:2])
print('不指定起始：',s[:2])
print('不指定结束：',s[2:])
print('指定区间、指定步长',s[0:3:2])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4.字符串编码解码

# Author : zxy
# Date : 2022/5/4 16:49

# 字符串的编码解码
"""
为什么需要字符串的编码转换：
    计算机之间的传输是通过byte字节，在计算机展示的时候是字符
编码和解码的方式：
    编码：将字符串转换为二进制数据bytes
    解码：将bytes类型的数据转换成字符串类型
"""

s = '大河向东流'

# 编码
print(s.encode(encoding='GBK')) # 一个中文字符，两个字节
print(s.encode(encoding='UTF-8')) # 一个中文字符，三个字节

# 解码
byte = b'\xb4\xf3\xba\xd3\xcf\xf2\xb6\xab\xc1\xf7'

print(byte.decode(encoding='GBK'))

byte = b'\xe5\xa4\xa7\xe6\xb2\xb3\xe5\x90\x91\xe4\xb8\x9c\xe6\xb5\x81'
print(byte.decode(encoding='UTF-8'))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

5.字符串驻留机制

# Author : zxy
# Date : 2022/5/4 10:41

# 字符串的驻留机制
"""
字符串：
    在Python中字符串是基本数据类型，是一个不可变的字符序列
什么叫字符串驻留机制？
    仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，
    Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同的字符串时，
    不会开辟新的空间，而是把该字符串 的地址赋给新创建的变量
"""
a = 'python'
b = "python"
c = """python"""
print('----------相同字符串，相同地址------------')
print(a,id(a))
print(b,id(b))
print(c,id(c))
print(a is b , b is c , c is a)

"""
驻留机制的几种情况：
    字符串长度为0或1时
    符合标识符的字符串
    字符串只在编译时进行驻留，而非运行时
    [-5,256]之间的整数数字
sys中intern方法强制2个字符串指向同一对象
pycharm对字符串进行了优化处理
"""

"""
Python 3.7.0 (v3.7.0:1bf9cc5093, Jun 27 2018, 04:59:51) [MSC v.1914 64 bit (AMD64)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> s1 = 'abc'
>>> s2 = 'abc'
>>> s1 is s2
True
>>> s1 = 'abc%'
>>> s2 = 'abc%'
>>> s1 is s2
False
>>> s1 == s2
True
>>> 
"""


# 字符串驻留的优缺点
"""
字符串驻留的优缺点：
    当需要值相同的字符串时，可以直接从字符串池中拿来使用，
    避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是比较影响性能的
    
    在需要进行字符串拼接的时候建议使用str类型的join方法，而非+，
    因为join()方法是先计算出所有字符中的长度，然后拷贝，只new一次对象，效率比+更高
"""
# >>> c = ''.join(['ab','c'])
# >>> c
# 'abc'
# >>> c = 'a'.join(['b','c'])
# >>> c
# 'bac'
# >>>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

6.格式化字符串

# Author : zxy
# Date : 2022/5/4 16:21

# 格式化字符串
"""
格式化字符串的两种方式
    %作为占位符: '我的名字叫：%s,今年%d岁了' % (name,age)
        字符串：%s
        整数：%l 或 %d
        浮点数：%f
    {}作为占位符: '我的名字叫：{0},今年{1}岁了，我真的叫{0} format(name,age)
"""

name = 'zxy'
age = 18

print('我叫%s,我今年%d岁了' % (name,age))


print('我叫{0},我今年{1}岁了，我真的叫{0}'.format(name,age))


# 长度为10，保留小数点后三位
print('%10.3f' % 3.1415926)

print('{}'.format(3.1415926)) # 只有一个元素，不指定位置也可
print('{0:.3}'.format(3.1415926)) # 总共保留三位数
print('{0:.3f}'.format(3.1415926)) # 保留三位小数
print('{0:10.3f}'.format(3.1415926)) # 设置宽度和精度，一共十位，保留小数点后三位

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

第七章

1.函数

# Author : zxy
# Date : 2022/5/4 17:22

# 函数
"""
什么是函数：
    函数是执行特定任务和完成特定功能的一段代码
为什么需要函数：
    提高代码可复用性
    隐藏实现细节
    提高可维护性
    提高可读性
函数的创建：
    def 函数名([输入参数]):
        函数体
        [return xxxx]
"""

"""
    在函数调度过程中，进行参数的传递
    如果是不可变对象，在函数体的修改不会影响实参的值
    如果是可变对象，在函数体的修改会影响到实参的值
"""
def cale(a,b): # a,b为形参
    return a + b

if __name__ == '__main__':
    a = cale(10,20) # 10,20 是实参
    print(a)
    b = cale(b=100,a=10) # 指定参数赋值
    print(b)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

2.函数返回值

# Author : zxy
# Date : 2022/5/4 18:55
# 函数返回值
"""
函数返回值：
    如果函数没有返回值 return可以不写
    函数的返回值，如果是一个，直接返回类型
    函数返回值，如果是多个，返回结果为元组
"""
# 函数返回多个值，结果为元组
def fun(num):
    odd = []
    even = []
    for i in num:
        if i % 2 == 0 :
            odd.append(i)
        else:
            even.append(i)
    return odd,even

if __name__ == '__main__':
    lists = [10,23,45,23,85,12]
    print('元组：',fun(lists))
    # 函数返回多个值，可以使用下标取值
    print('列表1',fun(lists)[0])
    print('列表2',fun(lists)[1])
    # for i,j in fun(10):
    #     print(i)
    #     print(j)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

3.函数默认值

# Author : zxy
# Date : 2022/5/4 19:49


def fun(a,b=20):
    # 这里的为end='\t'也是给end指定传参，这样就不会使用默认值end='\n'
    # def print(self, *args, sep=' ', end='\n', file=None):
    print('begin1',end='\t')
    print('beigin2')
    return a+b

if __name__ == '__main__':
    a = fun(10)
    print('未给b传参，则b使用默认值',a)
    b = fun(10,30)
    print('给a,b指定传参，则默认值失效',b)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4.位置参数和关键字参数

# Author : zxy
# Date : 2022/5/4 20:01

# 函数得参数定义
"""
个数可变得位置参数：
    定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数
    使用*定义个数可变的位置形参
    结果为一个元组
个数可变的关键字形参：
    定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参
    使用**定义个数可变的关键字形参
    结果为一个字典
"""
def fun1(*args):
    print(args,type(args))

def fun2(**args):
    print(args,type(args))

if __name__ == '__main__':
    fun1(10,20,30)
    fun2(a=10,b=20,c=30)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

5.参数总结

# Author : zxy
# Date : 2022/5/4 21:07

# 参数总结

def fun(a,b,c):
    print('a={0},b={1},c={2}'.format(a,b,c))

def fun2(a,b,c,d):
    print('a={0},b={1},c={2},d={3}'.format(a, b, c,d))
if __name__ == '__main__':
    fun(10,20,30) # 位置传参
    fun(a=10,b=20,c=30) # 关键字传参
    lst = [10,20,30]
    fun(*lst) # 使用lst传参的时候，需要使用*，将列表中的元素依次传给函数fun()
    dic = {'a':10,'b':20,'c':30}
    fun(**dic)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

6.变量的作用域

# Author : zxy
# Date : 2022/5/4 21:31

# 变量的作用域
"""
变量的作用域：
    程序代码能访问该变量的区域
    根据变量的有效范围可分为：
        局部变量：
            在函数内定义并使用的变量，只有在函数内部有效，
            局部变量使用global声明，这个变量就会变成全局变量
        全局变量：
            函数体外定义的变量，可作用于函数内外

"""
b = 'hello python'
def fun():
    a = 'hello word'
    global c
    c = 'hello java'
    print('局部变量',a)
    print('global局部变量转全局变量',c)
if __name__ == '__main__':
    print('全局变量', b)
    fun()
    # global将局部变量转为全局变量，定义在fun()函数中，需要先调用fun()函数，才能使用全局变量c
    print('global局部变量转全局变量',c)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

7.递归函数

# Author : zxy
# Date : 2022/5/4 21:48

#递归函数
"""
什么是递归函数？
    如果在一个函数的函数体内调用了该函数本身，这个函数就成为递归函数
递归的组成部分？
    递归调用与递归终止条件
递归的调用过程？
    每递归调用一次函数，都会在栈内存分配一个栈帧
    每执行完一次函数，都会释放相应的空间
递归的优缺点？
    缺点：占用内存多，效率底下
    优点：思路和代码简单
"""

def fun(n):
    if n == 1:
        return 1
    else:
        return n * fun(n-1)


if __name__ == '__main__':
    print(fun(6))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

8.斐波那契

# Author : zxy
# Date : 2022/5/4 22:09

# 斐波那契
"""
                                                fun(6)
                          fun(5)                                      fun(4)
              fun(4)                  fun(3)                  fun(3)              fun(2)
      fun(3)          fun(2)  fun(2)          fun(1)    fun(2)        fun(1)        .
fun(2)     fun(1)        .       .              .         .             .           .
.           .            .       .              .         .             .           .
.           .            .       .              .         .             .           .
1           1            1       1              1         1             1           1
"""
def fun(n):
    if n == 1:
        return 1
    elif n == 2:
        return 1
    else:
        return fun(n-1) + fun(n-2)

if __name__ == '__main__':
    print(fun(6))


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

第八章

1.bug

# Author : zxy
# Date : 2022/5/4 22:35

# 1.规范操作
"""
1.漏末尾的冒号
2.缩进错误
3.英文字符写成中文
4.字符串连接，把字符串和数字拼接到一起
5.没有定义变量
6.比较运算符==和赋值运算符=的混用
"""

# 2.知识点不熟练导致错误
"""
1.索引越界：indexError
    lst = [11,22,33,44]
    print(lst[4])
2.append()方法使用不熟练
    lst=[]
    lst=append('A','B','C')
    print(lst)
"""

# 3.思路不清导致的问题
"""
基础知识不牢固，练
"""


'''列表套字典，字典里的value值有列表'''
lst = [{'rating':[9.7,2062397],'id':'1292052','type':['犯罪','剧情'],'title':'肖申克的救赎','actors':['蒂姆.罗宾斯','摩根.弗里曼']},
       {'rating':[9.6,1528760],'id':'1291546','type':['剧情','爱情','同性'],'title':'霸王别姬','actors':['张国荣','张丰毅','巩俐','葛优']},
       {'rating':[9.5,1559181],'id':'1292720','type':['剧情','爱情'],'title':'阿甘正传','actors':['汤姆.汉克斯','罗宾.怀特']}]

name = input('请输入你要查询演员的名字:')

for movie in lst:
    actor = movie['actors']
    for act in actor:
        if(name in act):
            print(name + '出演了' + movie['title'])



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

2.Python常见的异常类型

# Author : zxy
# Date : 2022/5/20 14:55


# Python常见的异常类型

ZeroDivisionError #除或取模零的类型
IndexError #序列中没有此索引
KeyError #映射中没有这个键
NameError #未声明/初始化对象(没有属性)
SyntaxError  #Python语法错误
ValueError #传入无效的参数

1
2
3
4
5
6
7
8
9
10
11
12
13

3.异常处理机制

# Author : zxy
# Date : 2022/5/20 14:05



# 1.try: ... except Error:...
"""
1.问题
程序代码逻辑没有错，只是因为用户错误操作或者一些例外情况而导致的程序崩溃
例如：除数不可以为0
     没有按照输入类型输入指定类型数据
2.解决
针对这种问题，Python提供了异常处理机制，可以在异常的时候出现0时即捕捉，然后内部"消化"，让程序继续运行
    try ... except Error:
捕获异常的顺序按照先子类后父类的顺序，为了避免遗漏可能出现的异常，可以在最后增加BaseException
"""

try:
    n1 = int(input('请输入一个整数：'))
    n2 = int(input('请输入另一个整数:'))
    result = n1 / n2
    print('结果为：',result)
except ZeroDivisionError:
    print('除数不可以为0')
except ValueError:
    print('值异常')

except BaseException as e:
    print(e)

# 2.try...except...else结构
"""
如果try块中没有抛出异常，则执行else,如果抛出异常，则执行except
"""

try:
    n1 = int(input('请输入一个整数：'))
    n2 = int(input('请输入另一个整数:'))
    result = n1 / n2
except ZeroDivisionError:
    print('除数不可以为0')
else:
    print('结果为：',result)

# 3.try...except...else...finally
"""
finally块无论如何是否发生异常都会被执行，能常用来释放try块中申请的资源
"""
try:
    n1 = int(input('请输入一个整数：'))
    n2 = int(input('请输入另一个整数:'))
    result = n1 / n2
except ZeroDivisionError:
    print('除数不可以为0')
else:
    print('结果为：',result)
finally:
    print('无论是否抛出异常，都会执行finally，输出这一句')

# 4.try...except...else...finally

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

4.TraceBack模块的使用

# Author : zxy
# Date : 2022/5/20 22:03

"""
使用traceback模块打印异常信息
"""
import traceback

try:
    print('测试'.center(10,'*'))
    print(1/0)
except:
    traceback.print_exc()

1
2
3
4
5
6
7
8
9
10
11
12
13
14

第九章

1.两大编程思想

# Author : zxy
# Date : 2022/5/20 22:14

"""
面向过程：
    事物比较简单，可以线性的思维去解决
面向对象:
    事务比较复杂，使用简单的线性思维无法解决
共同点：
    面向过程和面向对象都是解决实际问题的一种思维方式

联系：
    二者相辅相成，并不是对立的
    解决复杂问题，通过面向对象方式便于我们从宏观把握事务之间复杂的关系，
    方便分析整个系统；具体到微观操作，仍然使用面向过程来处理

"""

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.类和对象的理解

# Author : zxy
# Date : 2022/5/20 22:14

# 1.类和对象
"""
类：
    类是多个类似事物组成的群体的统称。能够帮助我们快速的理解和判断事物的性质
数据类型：
    不同数据类型属于不同的类
    使用内置函数type()查看数据类型
    例如：
        print(type(10))
        print(type(20))
对象：
    10,20都是Int类之下包含相似的不同个例，这个个例的专业术语称为实例或对象
"""



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3.类和对象的创建

# Author : zxy
# Date : 2022/5/20 22:46


# 1.类的创建
"""Student为类的名称，由一个或多个单词组成，每个单词首字母大写，其余小写"""
class Student:
    # 直接写在类里的变量，称为类属性
    address = '上海'
    # name,age为实例属性
    def __init__(self,name,age):
        self.name = name
        self.age = age
    # 实例方法
    """在类之外定义的称为函数，在类之内定义的称为方法"""
    def info(self):
        print('name:',self.name,'age:',self.age)
    # 类方法
    @classmethod
    def cm(cls):
        print('类方法')
    # 静态方法
    @staticmethod
    def sm():
        print('静态方法')

# 2.对象的创建
"""
对象的创建又称为类的实例化
语法：
    实例名=类面()

"""
stu = Student('zxy','01')
print(stu.name)
print(stu.age)
stu.info() # 方法一：对象名.方法名()
Student.info(stu) # 方法二：类名.方法名(类的对象) -》 实际上就算定义处的self


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

4.类属性-类方法-静态方法

# Author : zxy
# Date : 2022/5/20 23:23

# 类属性、类方法、静态方法
"""
类属性：类中方法外的变量称为类属性，被该类所有对象共享
类方法：使用@classmethod修饰的主法，使用类名点直接访问的方法
静态方法：使用 @staticmethod修饰的主法，使用类名点直接访问的方法
"""

class Student:
    # 直接写在类里的变量，称为类属性
    address = '上海'
    # name,age为实例属性
    def __init__(self,name,age):
        self.name = name
        self.age = age
    # 实例方法
    """在类之外定义的称为函数，在类之内定义的称为方法"""
    def info(self):
        print('name:',self.name,'age:',self.age)
    # 类方法
    @classmethod
    def cm(cls):
        print('类方法')
    # 静态方法
    @staticmethod
    def sm():
        print('静态方法')


# 类属性调用
print(Student.address)
Student.address = '杭州'
print(Student.address)

# 类方法调用
Student.cm()

# 静态方法的调用
Student.sm()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

5.动态绑定属性和方法

# Author : zxy
# Date : 2022/5/20 23:39

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

    def info(self):
        print('my name is ',self.name,', i am', self.age,' years old')

stu1 = Student('张三',20)
stu2 = Student('李四',30)
print('-----------------属性----------------------------')
print('为stu1动态绑定性别属性')
stu1.gender = '女'
print(stu1.name,stu1.age,stu1.gender)
print('为stu2动态绑定ID属性')
stu2.id = 100
print(stu2.name,stu2.age,stu2.id)
print('-----------------方法----------------------------')
def show():
    print('测试动态绑定方法')
stu1.show = show
stu1.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

第十章

1.继承

# Author : zxy
# Date : 2022/5/21 10:01

# 继承
"""
父类：动物
子类：猫 、 狗 、 鸟继承动物的属性
如果一个类没有继承任何类，则默认继承Object
Python支持多继承
定义子类的时候，必须在其构造参数中调用父类的构造函数

"""

class Person(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def info(self):
        print('姓名：{0},年龄：{1}'.format(self.name,self.age))

# 定义子类
class Student(Person):
    def __init__(self,name,age,score):
        super().__init__(name,age)
        self.score = score

# 定义子类
class Teacher(Person):
    def __init__(self,name,age,subject):
        super().__init__(name,age)
        self.subject = subject


# 测试
stu = Student('zxy',1,100)
stu.info()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

2.封装

# Author : zxy
# Date : 2022/5/20 23:57

# 面向对象的三大特征：
"""
封装：提高程序的安全性
    将数据(属性)和行为(方法)包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法
    这样就无需关系内部的具体实现细节，从而降低复杂度

    在Python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个"_"

继承：提高代码的复用性
多态：提高程序的可扩展性和可维护性
"""

# 封装
class Student:
    def __init__(self,name,age):
        self.name = name
        ## age前加两个下划线，表示不希望被类外使用
        self.__age = age
    def show(self):
        print('name is ', self.name,'age is ',self.__age)

# 使用封装方法
try:
    stu = Student('张三',20)
    stu.show()
    print(stu.name)
    print(stu.age)

except AttributeError:
    print("Error : 'Student' object has no attribute 'age'")

finally:
    """
    尽管在类中，age属性被添加两个下划线来表示不可被外部调用
    但是可以通过dir查看对象，发现_Student__age的属性
    """
    print(dir(stu))
    print(stu._Student__age)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

3.多态

# Author : zxy
# Date : 2022/5/21 10:01

# 多态

"""
    简单的说，多态就算“具有多种形态”，它指的是：
即使不知道一个变量所引用对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，
动态决定调用哪个对象中的方法
"""

# 静态语言和动态语言
# 静态语言如Java
# 动态语言如Python
"""
静态语言实现多态的三个必要条件：
    1。继承
    2.方法重写
    3.父类引用指向子类对象
动态语言的多态崇尚“鸭子类型”，当看到一只鸟走路像鸭子，游泳像鸭子，收起来像鸭子，那么这只鸟就可以被称为鸭子。
在鸭子的类型中，不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为
"""

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

4.方法重写

# Author : zxy
# Date : 2022/5/21 10:01

# 方法重写

"""
如果子类对继承的父类的某个属性或方法不满意，可以在子类中对其进行重写编写
子类重写后的方法中可以通过super().方法名()调用父类中被重写的方法
"""

class Person(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def info(self):
        print('姓名：{0},年龄：{1}'.format(self.name,self.age))

# 定义子类
class Student(Person):
    def __init__(self,name,age,score):
        super().__init__(name,age)
        self.score = score

    def info(self):
        super().info()
        print('成绩：{0}'.format(self.score))

# 定义子类
class Teacher(Person):
    def __init__(self,name,age,subject):
        super().__init__(name,age)
        self.subject = subject

    def info(self):
        super().info()
        print('学科：{0}'.format(self.subject))



# 测试
stu = Student('zxy',1,100)
stu.info()

tea = Teacher('Mr.zxy',2,'数学')
tea.info()



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

5.特殊属性

# Author : zxy
# Date : 2022/5/21 10:02

# 特殊方法和特殊属性

"""
特殊属性:
    __dict__ : 获得对象或实例对象所绑定的所有属性和方法的字典
特殊方法：
    __len__() : 通过重写__len__()方法，让内置函数len()的参数可以是自定义类型
    __add__() : 通过重写__add__()方法，可以使用自定义对象具有'+'功能
    __new__() : 用于创建对象
    __init__() : 对创建的对象进行初始化

"""

class A(object):
    pass
class B(object):
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name = name
        self.age = age

c = C('zxy',1)
print(c.__dict__) # 实例对象c所有属性的字典
print(C.__dict__) # 类

print(c.__class__) # 输出对象所属类
print(C.__bases__) # 输出C类的父类元素
print(C.__base__) # 输出C类的第一个父类元素
print(C.__mro__) # 查看类的层次结构
print(A.__subclasses__()) # 查看A的子类




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

6.特殊方法

# Author : zxy
# Date : 2022/5/21 12:12

# 特殊方法和特殊属性

"""
特殊属性:
    __dict__ : 获得对象或实例对象所绑定的所有属性和方法的字典
特殊方法：
    __len__() : 通过重写__len__()方法，让内置函数len()的参数可以是自定义类型
    __add__() : 通过重写__add__()方法，可以使用自定义对象具有'+'功能
    __new__() : 用于创建对象
    __init__() : 对创建的对象进行初始化

"""

# 测试__add__()
a = 20
b = 30
c = a + b
d = a.__add__(b)  ## 调用a的对象__add__()方法

print(c)
print(d)

#  __len__() : 通过重写__len__()方法，让内置函数len()的参数可以是自定义类型
#  __add__() : 通过重写__add__()方法，可以使用自定义对象具有'+'功能
class Student():
    def __init__(self,name):
        self.name = name
    def __add__(self, other):
        return self.name + other.name
    def __len__(self):
        return len(self.name)

stu1 = Student('zzzz')
stu2 = Student('xx')

print('----------------------------__add__()------------------------')
stu3 = stu1 + stu2 # 重写__add__()方法
print(stu3)

print('----------------------------__len__()------------------------')

print(len(stu3))


# __new__() : 用于创建对象
# __init__() : 对创建的对象进行初始化
print('----------------------------__new__()-----__init__()-----------------------------------')
class Person():
    def __new__(cls, *args, **kwargs):
        print('cls的id为{0}',id(cls))
        obj = super().__new__(cls)
        print('创建对象ID为{0}'.format(id(obj)))
        return obj
    def __init__(self,name,age):
        print('调用__init__()，self的ID值为{0}'.format(id(self)))
        self.name = name
        self.age = age

print('object类对象的ID为{0}'.format(id(object)))
print('Person类对象的ID为{0}'.format(id(Person)))

# 创建Person的实例对象
per = Person('zxy',1)
print('per这个实例对象的ID为{0}'.format(id(per)))


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

7.Object

# Author : zxy
# Date : 2022/5/21 10:01


# Object类
"""
    1.Object类 是所有类的父类，因此所有类都有Object类的属性和方法
    2.有内置函数dir()可以查看指定对象所有属性
    3.Object有一个__str__()方法，用于返回一个对于“对象的描述”，
对于内置函数str()经常用于print()方法，帮我们查看对象的信息，
所以我们经常对__str__()进行重写
"""
class Person(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def info(self):
        print('姓名：{0}，年龄：{1}'.format(self.name,self.age))
    def __str__(self):
        return '姓名：{0}，年龄：{1}'.format(self.name,self.age)

obj = object()
print(dir(obj))

per = Person('zxy',1)
print(dir(per))
print(per) # 重写str方法，用于返回对象的描述


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

8.类的浅拷贝和深拷贝

# Author : zxy
# Date : 2022/5/21 15:22

# 类的浅拷贝和深拷贝

"""
变量的赋值操作
    只是形成两个变量，实际上还算指向同一个对象
浅拷贝：
    Python拷贝一般是浅拷贝，拷贝时，对象包含的子对象内容不拷贝。
因此，源对象与拷贝对象会引用捅一个子对象。
深拷贝：
    使用Copy模块的deepcopy函数，递归拷贝对象中包含的子对象，
源对象和拷贝对象所有的子对象也不相同

"""

class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu = cpu
        self.disk = disk

# 1.变量的赋值
cpu1 = CPU()
cpu2 = cpu1
print(cpu1,id(cpu1))
print(cpu2,id(cpu2))

# 2.浅拷贝
import copy
disk = Disk()
com = Computer(cpu1,disk)
com2 = copy.copy(com)
# 浅拷贝，由com复制到com2，发生变化，而子对象disk和cpu不发生变化
print(com,com.cpu,com.disk)
print(com2,com2.cpu,com2.disk)


# 3.深拷贝

com3 = copy.deepcopy(com)
# 深拷贝，由com复制到com3，源对象和子对象都被拷贝，从而发生变化
print(com,com.cpu,com.disk)
print(com3,com3.cpu,com3.disk)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

第十一章

1.主程序

# Author : zxy
# Date : 2022/5/21 16:35

# 以主程序运行
"""
    在每个模块的定义中都包括一个记录模块名称的变量__name__，程序可以
检查该变量，以确定他们在哪个模块中执行。如果一个模块不是被导入到其他程序
中执行，那么它可能在解释器的顶级模块中执行。顶级模块的__name__变量值为__main__
"""

def add(a,b):
    return a + b

def div(a,b):
    try:
        return a/b
    except ZeroDivisionError:
        return 0

if __name__ == '__main__':
    print(div(1, 2))


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2.包

# Author : zxy
# Date : 2022/5/21 16:42

# Python中的包
"""
包是一个分层次的目录结构，将一组功能相近的模块组织在一个目录下

作用：
    代码规范
    避免模块名称冲突

包与目录的区别：
    包含__init__.py文件的目录称为包,如chapter11/package
    目录里统称不包含__init__.py文件,如chapter11/dictory

包的导入：
    import 包名.模块名
"""

# 导入package包下的modeA模块
import package.modeA as pac

# 调用包下的modeA模块中的变量a
print(pac.a)

# 调用包下的modeA模块中的方法add()
print(pac.add(1, 2))




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

3.模块

模块的使用

# Author : zxy
# Date : 2022/5/21 16:26


# 自定义模块
"""
创建模块
    新建一个.py文件，名称尽量不要与Python自带的标准模块名称相同
导入模块
    import 模块名称 [as 别名]
    from 模块名称 import 函数/变量/类
"""
from math import pow

print(pow(2, 3))
# print(math.pi) 这里因为没有导入math模块中的pi,所以会报错

import math

print(math.pi)
print(dir(math))


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

自定义模块

# Author : zxy
# Date : 2022/5/21 16:12

# 自定义模块
"""
创建模块
    新建一个.py文件，名称尽量不要与Python自带的标准模块名称相同
导入模块
    import 模块名称 [as 别名]
    from 模块名称 import 函数/变量/类
"""

# 指定函数导入
from calc import add
print(add(1,2))

# 导入自定义模块calc的所有函数
import calc
print(calc.add(1,2))
print(calc.div(1,2))
print(calc.div(1,0))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

calc

# Author : zxy
# Date : 2022/5/21 16:30

def add(a,b):
    return a + b

def div(a,b):
    try:
        return a/b
    except ZeroDivisionError:
        return 0

1
2
3
4
5
6
7
8
9
10
11
12

4.Python内置模块

# Author : zxy
# Date : 2022/5/21 17:15

#Python常用的内置模块

"""
sys 与Python解释器及其操作相关的标准库
time 提供与时间相关的各种函数的标准库
os  提供访问操作系统服务功能的标准库
calendar    提供与日期相关的各种函数的标准库
urllib  用于读取来自网上(服务器)的数据标准库
json    用于使用JSON序列化和反序列化对象
re      用于在字符串中执行正则表达式匹配和替换
math    提供标准算术运算函数的标准库
decimal     用于进行精度控制运算精度，有效数位和四舍五入操作的十进制运算
logging     提供了灵活的记录事件、错误、警告和调试信息等日志的功能
"""

import sys
import time
import urllib.request #爬虫常用
import logging
print(sys.getsizeof(20))

print('秒',time.time())
print(time.localtime(time.time()))

print(urllib.request.urlopen('http://www.baidu.com').read())



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

5.第三方模块的安装和使用

# Author : zxy
# Date : 2022/5/21 17:41


# 安装 pip install 模块名
# pip install schedule
# 使用 import 模块名

import schedule
import time

def run():
    print('python')

# 定时调度任务，每三秒执行一次
schedule.every(3).seconds.do(run)

while True:
    # 启动调度
    schedule.run_pending()
    # 每次执行后休息1秒
    time.sleep(1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

6.导入注意事项

# Author : zxy
# Date : 2022/5/21 17:08

# 导入模块和包的时候注意事项

# 使用import导入的时候，只能跟包名或模块名
import package
import 主程序

# 使用from ...  import导入的时候，可以跟包、模块、函数、变量
from package import modeA
from package.modeA import a
from package.modeA import add


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

第十二章

1.文件的读写原理

# Author : zxy
# Date : 2022/5/21 18:10

#文件的读写原理

"""
文件的读写俗称IO操作
文件读写操作流程
操作原理

Python操作文件-》打开或新建文件-》读写文件-》关闭资源

通过IO流将磁盘文件中的内容与程序中的对象中的内容进行同步
file = open( filename [,mode,encoding])
file: 被创建的文件对象
open: 创建文件对象的函数
filename: 要创建或打开文件名称
mode: 打开默认只读模式
encoding: 默认文本中字符编写格式为GBK
"""

file = open('file','r')
words = file.readlines()
print(words) # readlines读取到的是列表
file.close()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

2.文件对象的常用方法

# Author : zxy
# Date : 2022/5/21 21:22

# 文件对象的常用方法
"""
read((size)) : 从文件读取size个字节或字符内容返回，若省略size，则一次性读完

readline() : 从文本文件中读取一行内容

readlines() : 把文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回

write(str) : 将字符串str内容写入文件

writelines(list) : 将字符串列表list写入文本文件，不添加换行

seek(offset,[whence]) : 把文件指针移动到新的位置，offset表示相对于whence的位置
    offset:为正往结束放心移动
    whence不同的值代表不同含义：
        0 ： 从文件头开始计算（默认值）
        1 ： 从当前位置开始计算
        2 ： 从文件尾开始计算

tell()
    返回文件指针的当前位置

flush()
    把缓冲区的内容写入文件，但不关闭文件

close()
    把缓冲区内容写入文件，同时关闭文件，释放文件对象相关资源
"""

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

3.常见文件打开方法

# Author : zxy
# Date : 2022/5/21 21:01

# 文件的类型
"""
按照文件中数据的组织形式，文件分为以下两大类：
    文本文件：通常以Unicode字符集存储，可以使用记事本程序打开，存储的是普通的字符文本
    二进制文件：把数据内容用字节存储，无法用记事本打开，必须使用专用的软件，比如mp3,jpg,doc等

打开模式：
    r : 只读模式，指针在文件开头
    w ： 只写模式，存在则覆盖内容，不存在则创建，指针在文件开头
    a : 追加模式，存在则追加，指针在文件末尾、不存在则创建，指针在文件开头
    b : 以二进制方式打开文件，不能单独使用，需要与其他模式一起使用，rb 或者 wb
    + : 以读写方式打开文件，不能单独使用，需要与其他模式一起使用，a+
"""
# 只读
file = open('file','r')
words = file.readlines()
print(words)
file.close()

# 只写
file = open('file','w')
lst = ['床前明月光\n','疑似地上霜']
words = file.writelines(lst)
file.close()

# 追加
file = open('file','a')
lst = ['\n举头望明月']
words = file.writelines(lst)
file.close()

# 二进制文件边读边写
readPng = open('CSDN.png','rb')
writePng = open('Copy.png','wb')
writePng.write(readPng.read())
readPng.close()
writePng.close()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

4.OS

OS模块常用方法

# Author : zxy
# Date : 2022/5/21 21:51

# os模块
"""
    os模块是Python内置的与操作系统功能和文件系统相关的模块，
该模块中的语句的执行结果通常与操作系统有关，在不同的操作系统上
运行，得到的结果可能不一样

    os模块与os.path模块用于对目录或文件进行操作

    getcwd() 返回当前的工作目录
    listdir(path) 返回指定路径下的文件和目录信息
    mkdir(path,[mode]) 创建目录
    makedirs(path1/path2...) 创建多级目录
    rmdir(path) 删除目录
    removedirs(path1/path2...) 删除多级目录
    chdir(path) 设置path为当前工作目录
"""

import os

# 1.调用命令
# os.system('notepad.exe')
# os.system('calc.exe')

# 2.直接调用可执行文件
# os.startfile('D:\\WeChat\\WeChat.exe')

# 3.打开
print(os.getcwd())

# 4.查看指定目录下的文件
print(os.listdir('E:\\BigData\\date\\PyCharm\\May2\\chapter1'))
print(os.listdir('../chapter1'))

# 5.当前目录下创建\删除文件
os.mkdir('test1')
os.rmdir('test1')

# 6.多级目录创建\删除
os.makedirs('test1\\test2')
os.removedirs('test1\\test2')

# 7.修改当前工作目录
os.chdir('E:\\BigData\\date\\PyCharm\\May2\\chapter11')


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

os.path模块操作目录相关函数

# Author : zxy
# Date : 2022/5/21 22:10

# os.path 模块操作目录相关函数
"""
abspath(path) 用于获取文件或目录的绝对路径
exists(path) 用于判断文件或目录是否存在，如果存在返回True，否则返回False
join(path,name) 将目录与目录或文件名拼接起来
splitext() 分离文件名和扩展名
basename(path) 从一个目录中提取文件名
dirname(path) 从一个路径中提取文件路径，不报错文件名
isdir(path) 用于判断是否为路径
"""

import os.path as  path

# 1.绝对路径
print(path.abspath('..'))
# 2.是否存在
print(path.exists('/chapter12'))
# 3.分割
# 3.1 分割目录和文件
print(path.split('/chapter12'))
# 3.2 分割文件名和扩展名
print(path.splitext('chapter12.py'))
# 4.分离文件名
filename = path.basename('/chapter12')
print(filename)

# 5.分离目录
dirname = path.dirname('/chapter12')
print(dirname)

# 6.将目录和文件名连接
print(path.join(dirname, filename))

# 7.是否为路径
print(path.isdir('/chapter12'))
print(path.isdir('chapter12'))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

案例_列出指定目录下所有py文件

# Author : zxy
# Date : 2022/5/21 22:38

import os

path = os.getcwd()
lst = os.listdir('E:/BigData/date/PyCharm/May2/chapter12')
lst_files = os.walk('E:/BigData/date/PyCharm/May2/chapter12')
for filename in lst:
    # 方法一：os.path模块实现
    """
    fileSplit = os.path.splitext(filename)
    if fileSplit[1] == '.py':
        print(filename)
    """
    # 方法二：
    if filename.endswith('.py'):
        print(filename)


# 2.递归遍历
print('递归遍历'.center(100,'*'))
for dirpath,dirname,filename in lst_files:
    # filename 是递归目录下的文件列表
    for file in filename:
        if file.endswith('.py'):
            print(file)

    """
    代码：
    
    print(dirpath)
    print(dirname)
    print(filename)
    print('------------')
    
    输出结果：
    
    E:/BigData/date/PyCharm/May2/chapter12
    ['os']
    ['Copy.png', 'copy2.png', 'CSDN.png', 'file', 'with语句.py', '常见文件打开模式.py', '文件对象的常用方法.py', '文件的读写原理.py', '编码格式.py']
    ------------
    E:/BigData/date/PyCharm/May2/chapter12\os
    []
    ['ospath模块操作目录相关函数.py', 'os模块常用函数.py', '案例_列出指定目录下所有py文件.py']
    ------------
    """

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

5.with语句

# Author : zxy
# Date : 2022/5/21 21:39

# With语句
"""
    with语句可以自动管理上下文资源，不论什么原因跳出with块，
都能确保文件正确的关闭，以此来达到释放资源的目的
"""

# 离开了with，就自动关闭文件
# 遵循上下文管理协议
with open('file','r') as read_file:
    print(read_file.read())

# 使用with语句重写，二进制文件边读边写
with open('copy.png','rb') as read_png:
    with open('copy2.png','wb') as write_png:
        write_png.write(read_png.read())

"""
readPng = open('CSDN.png','rb')
writePng = open('Copy.png','wb')
writePng.write(readPng.read())
readPng.close()
writePng.close()
"""

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

6.编码格式

# Author : zxy
# Date : 2022/5/21 17:54

# 编码格式
"""
Python的解释器使用的Unicode（内存）
.py文件在磁盘上使用UTF-8存储（外存）,如果需要修改存储类型，在.py文件开头第一行写：#encoding=gbk
"""

# GBK和UTF-8
"""
GBK英文一个字节，汉字两个字节
UTF-8英文一个字节，汉字三个字节
"""



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Python十四案例

1.ASCII码

# Author : zxy
# Date : 2022/5/24 23:10

a = 97
for i in range(0,26):
    print(chr(a+i),'----->',a+i)

1
2
3
4
5
6
7

2.enumerate函数

# Author : zxy
# Date : 2022/5/24 23:27
# Desc : enumerate函数，用于获取列表索引和数据

# 1.列表
year = [82,89,88,86,85,00,99]
print('原列表:',year)

for index,value in enumerate(year):
    if str(value) != '0':
        year[index] = int('19'+str(value))
    else:
        year[index] = int('200'+str(value))

print('调整后:',year)

# 2.元组
coffice_name = ('蓝山','卡布奇诺','拿铁','皇家咖啡')
print('您好，欢迎光临')
print('本店经营的咖啡有：')
for index,item in enumerate(coffice_name):
    print(index+1,'.',item,end=' ')

buy = int(input('\n请输入你想购买的品类:'))
print('你购买的[',coffice_name[buy-1],']咖啡已到货!')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

3.wordcount

# Author : zxy
# Date : 2022/5/26 14:24
def wordcount(words,word):
    count = 0
    for item in words:
        if word.upper() == item or word.lower() == item:
            count += 1
    return count

if __name__ == '__main__':
    words = 'helloworldhellopythonhelloJava'
    word = 'h'
    count = wordcount(words,word)
    print(count)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4.修改字体输出颜色

# Author : zxy
# Date : 2022/5/23 23:14
# Desc : 控制输出颜色

# 格式：
# 　　设置颜色开始 ：\033[显示方式;前景色;背景色m
# 说明：
# 前景色            背景色           颜色
# ---------------------------------------
# 30                40              黑色
# 31                41              红色
# 32                42              绿色
# 33                43              黃色
# 34                44              蓝色
# 35                45              紫红色
# 36                46              青蓝色
# 37                47              白色
# 显示方式           意义
# -------------------------
# 0                终端默认设置
# 1                高亮显示
# 4                使用下划线
# 5                闪烁
# 7                反白显示
# 8                不可见

print('\033[0:35m\t\tPython切换颜色打印\033[m')

print('\033[0:32m\t\tPython切换颜色打印\033[m')




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

5.列表倒叙输出

# Author : zxy
# Date : 2022/5/26 12:45
# Desc : 列表倒序输出

card = ['1001','1002','1003','1004']

print('正序输出...')
for i in card:
    print(i)

print('倒叙输出...')
# 从len(card)-1 到 -1依次输出，步长为-1
for i in range(len(card)-1,-1,-1):
    print(card[i])


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

6.十进制转二八十六

# Author : zxy
# Date : 2022/5/23 23:48
# Desc : 十进制转二进制、八进制、十六进制

def cale():
    number = int(input('请输入一个十进制数字:'))

    print('你输出的十进制数字为:{}'.format(number))
    print('你输出的二进制数字为:{}'.format(bin(number)))
    print('你输出的八进制数字为:{}'.format(oct(number)))
    print('你输出的十六进制数字为:{}'.format(hex(number)))

if __name__ == '__main__':
    while True:
        try:
            cale()
            break
        except:
            print('你输入有误！！！请重写输入')


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

7.向文件输入语句

# Author : zxy
# Date : 2022/5/23 21:15
# Desc : 向文件中输入语句

# 方式一：使用print方式输出文字，目的地是文件
fp = open('E:\\BigData\\date\\PyCharm\\PythonStudy\\action\\test1.txt','w')

print('Good Good Study，Day Day Up',file=fp)

fp.close()

# 方式二：是哦那个with上下文管理器
with open('E:\\BigData\\date\\PyCharm\\PythonStudy\\action\\test2.txt','w') as file:
    file.write('好好学习，天天向上')


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

8.字符串分割

# Author : zxy
# Date : 2022/5/28 0:42

class Student(object):
    def __init__(self,stu_name,stu_age,stu_gender,stu_score):
        self.stu_name = stu_name
        self.stu_age = stu_age
        self.stu_gender = stu_gender
        self.stu_score = stu_score

    def show(self):
        print(self.stu_name,self.stu_age,self.stu_gender,self.stu_score)

# 列表中存储对象，然后通过对象调用类中函数
if __name__ == '__main__':
    print('请输入五位学生信息，(姓名-年龄-性别-成绩)')
    lst = []
    for i in range(0,2):
        s = input(f'请输入入第{i+1}位学生的信息和成绩:')
        s_lst = s.split('-')
        stu = Student(s_lst[0],int(s_lst[1]),s_lst[2],float(s_lst[3]))
        lst.append(stu)

    for item in lst:
        item.show()


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

9.异常抛出

# Author : zxy
# Date : 2022/5/26 14:52
# 手动抛出异常: raise Exception('')
# 自动抛出异常: try...except...

score = int(input('请输入一个分数:'))
try:
    if 0 <= score <= 100:
        print('分数为:',score)
    else:
        raise Exception('分数超出范围!!!')
except Exception as e:
    print(e)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

10.格式化字符串输出

# Author : zxy
# Date : 2022/5/23 23:28
# 格式化字符串输出

height = 170

weight = 50.5

bmi = weight / (height + weight)

# 6种格式化方式
print('身高',height,'的你体重',weight)
print('身高'+str(height)+'的你体重'+str(weight))
print('身高{0}的你体重{1}'.format(height,weight))
print(f'身高{height}的你体重{weight}')
print('身高%s的你体重%s' % (height,weight))

print('你的BMI指标是:' + '{:0.7f}'.format(bmi))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

11.格式化时间类型

# Author : zxy
# Date : 2022/5/28 11:00
import time

if __name__ == '__main__':
    print(time.time())
    print(time.localtime(time.time()))
    print(time.strftime('%Y-%m-%d  %H:%M:%S',time.localtime(time.time())))


1
2
3
4
5
6
7
8
9
10

12.登录支付功能

# Author : zxy
# Date : 2022/5/24 0:07
# Desc : 验证登录用户名，密码;设置限制支付密码只允许是数字

def login(username,password):
    if username == 'admin' and password == '123456':
        print('登录成功！！')
        return True

if __name__ == '__main__':
    while True:
        username = input('请输入用户名:')
        password = input('请输入密码:')
        if login(username,password):
            pay = input('请输入支付密码:')
            """
            if条件成立，则将开头的字符串输出，否则输出else后的字符
            """
            print('支付密码合法' if pay.isdigit() else '支付密码不合法，只能由数字组成！！')
            break

        else:
            print('账号密码错误，请重新登录！！！')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

13.遍历两个列表输出

# Author : zxy
# Date : 2022/5/23 21:22
# Desc : 循环遍历两个列表中数据

# 1.列表输出
lst_type = ['id','name','age']
lst_data = ['001','zxy','5']

for i in range(len(lst_type)):
    print(lst_type[i],':',lst_data[i])

# 2.字典输出
dic_data = {'id':'001','name':'zxy','age':'5'}
for i in dic_data:
    # print(i, ':', dic_data[i])
    print(i,':',dic_data.get(i))

# 3.列表转元组输出
lst_type = ['id','name','age']
lst_data = ['001','zxy','5']

for i,j in zip(lst_type,lst_data):
    print(i,':',j)

# 4.列表转字典输出
dict_list = dict(zip(lst_type, lst_data))
for i in dict_list:
    print(i,dict_list[i])


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

14.列表

# Author : zxy
# Date : 2022/5/26 14:10

phones = set()

for i in range(5):
    info = input(f'请输入第{i+1}个朋友的姓名和手机号:')
    phones.add(info)

for item in phones:
    print(item)


1
2
3
4
5
6
7
8
9
10
11
12
13

-END-

---

学好 Python 不论是就业还是做副业赚钱都不错，但要学会 Python 还是要有一个学习规划。最后给大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！

包括：Python激活码+安装包、Python web开发，Python爬虫，Python数据分析，人工智能、机器学习、自动化测试带你从零基础系统性的学好Python！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/153180