Python学习笔记零基础_p1 = str(request.get.get('start_date'))语句得到的是什么

Python

​ 解释型语言：不需要编译

​ 交互式语言：在“>>>”直接运行代码

​ 面向对象语言：支持面向对象的风格或将代码封装到对象里的编程技术

基础语法

python中使用缩进表示代码块(代码块)，不需要大括号{}

标识符

用户编程时使用的名字，用于给变量、常量、函数、语句块等命名。

python中的保留字（关键字）

>>>import keyword
>>>keyword.kwlist
['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
1
2
3

python中6种的标准数据类型

python中有6个标准数据类型：

数字数据类型（Number）

字符串数据类型（String）

元组数据类型（Tuple）

列表数据类型（List）

集合数据类型（Set）

字典数据类型（Dictionary）

可变数据类型：列表、字典、集合

不可变数据类型：数字、元组、字符串

列表(list)

# 声明
names = ['jack','tom','lucy','superman','ironman']

computer_brands = []

# 地址

print(id(names))
print(id(computer_brands))

# 增删改查
#查 通过下标

# 元素获取使用： 下标      索引
print(names[0])
print(names[1])

# 获取最后一个元素
print(names[-1])

print(len(names))

print(names[len(names)-1])

# 获取第一个元素
print(names[-5])

# 结合循环

for i in 'hello':
   print(i)

print('*****************')

for name in names:
   print(name)

# 查询names里面有没有superman
for name in names:
   if name == 'superman':
      print('有超人在里面！')
      break
else:
   print('没有超人在里面！')


# 简便 't' in 'they'   -------> Ture or False 

if 'superman' in names:
   print('有超人在里面！')
else:
   print('没有超人在里面！')

# 增删改

brands = ['hp','dell','支持华为','thinkpad','lenovo','mac','神州']

# 改

for i in range(len(brands)):
   # i 是0，1，2，3，4，。。。。
   if '华为' in brands[i]:

      brands[i] = 'HUAWEI'
      break

print(brands)

# 删

l = len(brands)
i = 0
while i<l:
   if 'hp' in brands[i] or 'mac' in brands[i]:
      del brands[i]
      l-=1
   i+=1

print(brands)


'''
words = ['hello','good','goods','apple','world','digit','alpha']

提示输入一个单词： hello,如果输入的单词在列表里则删除

最后打印删除的列表

'''
words = ['hello','good','goods','apple','world','digit','alpha']

w = input('请输入一个单词：')


# 方式一：
if w in words:
   print('存在此单词！')

for word in words:
   if w == word:
      print('存在此单词！')
      break




# 删除   注意露删情况

w = input('请输入一个单词：')

i = 0

l = len(words)    # 5

while i<l:       # i<5
   if w in words[i]:
      del words[i]
      l-=1
      #i-=1
      continue


   i+=1


print(words)
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

字符串切片操做

# 字符串切片操作

# s = 'abcdefg' s[2:5] ----->cde



# 标号

list1 = ['杨超越','热巴','佟丽娅','杨幂','赵丽颖','刘亦菲','黑嘉嘉',100,99.9]

print(list1)

print(list1[3])

#列表也是支持切片

print(list1[3:6])   # 将截取的结果再次保存在一个列表中['杨幂','赵丽颖','刘亦菲']

print(list1[-3:-1])

print(list1[::2])   # 支持步长

print(list1[-5:-1:2])

# 反方向 从右向左
print(list1[-1: ])

print(list1[-1::-2])  # [99.9,'黑嘉嘉','赵丽颖','佟丽娅','杨超越']
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

列表的增删改查

# list 列表的添加：
# 临时小数据库：list

# 创建一个空列表

girls = ['杨幂']
# quit 表示退出

# 列表的函数使用：append      extend    insert

# append() 末尾追加
# while True:

#  name = input('请输入心目中的美女名字：')
#  if name == 'quit':
#     break

#  girls.append(name)
# print(girls)
# extend   类似发列表的合并
names = ['黑嘉嘉','孙俪','巩俐','王丽坤']

# girls.extend(names)

# print(girls)

# 符号  + 在字符串中叫拼接 在列表的合并

girls = girls+names
print(girls)


# insert  指定位置插入
# append  末尾追加
# extend  一次添加多个元素

girls.insert(1,'刘涛')

print(girls)

# 产生10个随机数，将其保存到列表中

import random

# random_list = []

# for i in range(10):
#  ran = random.randint(1,50)
#  # 保存到列表中
#  random_list.append(ran)

# print(random_list)


# 产生十个不同的随机数，将其保存在列表中

# 方式一：

random_list = []

i = 0
while i <10:

   ran = random.randint(1,20)
   if ran not in random_list:
      random_list.append(ran)
      i+=1
   else:
      pass

print(random_list)

# 方式二：

# for i in range(10):

#  ran = random.randint(1,20)
#  if ran not in random_list:
#     random_list.append(ran)

# print(random_list)   #  !!!!个数不是10个


# # 找出列表中的最大值  max(list)----->列表中的最大值  min(list)-------->列表中的最小值

max_value = max(random_list)
print(max_value)

min_value = min(random_list)
print(min_value)

print('-------------自定义求最大值和最小值-------------')

# 假设列表的第一个元素就是最大值
mvalue = random_list[0]
minvalue = random_list[0]

for value in random_list:
   if value>mvalue:
      mvalue = value

   if value<minvalue:
      minvalue = value

print('最大值是：',mvalue,'最小值是：',minvalue)

# 求和

he = sum(random_list)
print('系统求和：',he)

print('-------自定义求和--------')

sum_1 = 0

for value in random_list:
   sum_1+=value

print('和是：',sum_1)


# 排序： sorted 排序 默认是升序
# sorted(list)  ----> 默认升序  1，2，3，4，5，6
# sorted(list,reverse=True)  -----> 降序 6，5，4，3，2，1


sorted(random_list,reverse=True)
print(new_list)
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

# 列表的函数：
'''
字符串函数：
'abc'.split('-')
['a','b','c'].split('-')错误

列表函数： 只有通过列表才可以调出来的函数


添加：append  extend insert
删除：del list[index]
    remove(e) 删除列表中第一个出现的元素e，返回值是none。
            如果没有找到则报异常
    pop()  ： 弹栈  移除列表中最后一个元素  
               返回值是删除的元素
               默认是删除最后一个元素，但是可以指定index(下标)删除
    clear()      清除列表 删除所有元素
翻转：
   reverse()

排序：
   sort()

次数：
   count()



队列： 先进先出FIFO  first in first out
栈： 先进后出
'''

hotpot_list = ['海底捞','呷脯呷脯','张亮麻辣烫','热辣一号','宽板凳']

hotpot_list.append('张亮麻辣烫')

print(hotpot_list)


result = hotpot_list.pop()
print(result)
print(hotpot_list)

result = hotpot_list.pop(2)
print(result)
print(hotpot_list)

# result = hotpot_list.clear()

# print(result)
# print(hotpot_list)


print('----------倒序输出区别-----------')



# hotpot_list.reverse()
# print(hotpot_list)     # 倒序输出  改变了原列表元素的位置

print(hotpot_list[::-1])   # 只是逆序拿出列表中的元素
print(hotpot_list)       # 没有改变原列表

# 系统提供的排序
'''
sorted(list)
list.sort()
'''

l = [4,8,1,8,9,5,7]
l.sort(reverse=True)

print(l)


print(l.count(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
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

元组(tuple)

'''
总结列表：
list
1. 定义

l = [] 空列表
l = ['aaaaa']

2.符号
+ ------>合并 []+[]
* -------> []*n
in ------> a in []  False  True
not in ----->
is  地址是否相等
not is 

3. 系统中给列表用的函数：
len(list)  ----> int
sorted(list)  ----> 排序
max()   最大值
min()   最小值
list()  强制转换成列表类型
enumerate(list)  枚举  index value

4. 列表自身函数：
添加元素：
   append()   末尾添加
   extend()   末尾添加一组元素
   insert()   指定位置插入

删除：
   del list[index]

   remove(obj)       删除指定的元素，如果指定元素不存在则报异常

   pop()     队列 FIFO   栈    FILO  默认删除末尾元素即最后一个元素

   clear()       清空元素

其他：
   count()       统计指定元素的个数
   sort()    排序
   reverse()     翻转   [4,6,8,9,0]  ---->   [0,9,8,6,4]
算法：
   选择排序
   冒泡排序

'''

'''
元组：
类似列表（当成容器）
特点：
1.定义的符号：()
2.元组中的内容不可修改
3.关键字：tuple

列表                 元组
[]                ()
[1]                   (1,)
[1,2]              (1,2)
'''

t1 = ()
print(type(t1))       # <class'tuple'>

t2 = ('hello',)
print(type(t2))

t3 = ('aa','bb')
print(type(t3))



# 

t4 = (3,5,7,8,1,4,8,9,0)


# 增删改  查

import random

list1 = []

for i in range(10):
   ran = random.randint(1,20)

   list1.append(ran)

print(list1)

# tuple()
# list()
t5 = tuple(list1)
print(t5)

# 查询： 下标index  切片  [:]
print(t5[0])
print(t5[-1])

print(t5[2:-3])
print(t5[::-1])

# 最大值  最小值

print(max(t5))
print(min(t5))

# 求和
print(sum(t5))

# 求长度
print(len(t5))

# 元组中的函数：
# index()  --->个数
# count()  ---->位置

print(t5.count(4))    # 从这个元组中找到4的个数

print(t5.index(4))     # 从这个元组中找到4的位置
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

# 拆包

t1 = (4,7,3)

# a,b = t1   # ValueError: too many values to unpack(拆包) (expected(希望， 盼望) 2）
# x,y,z=(6,)  # ValueError: not enough values to unpack (expext 3, got 1)
a,b,c = t1

print(a,b,c)

a=t1

print(a)

# 变量个数与元组个数不一致
t1 = (2,5,8,9,7)

a,*_,c = t1
print(a,c,_)

a,b,*c = t1
print(a,b,c)

t1 = (9,)
a,*b = t1
print(a,b) # *b 表示未知个数的元素 放进[]列表中

print(*b)    #


'''
元组：
1.符号：(1,2,3)
2.关键字:tuple
3.元组的元素只能获取，不能增删改

符号：
+
*
is  not
in   not in 

系统函数：
max()
min()
sum()
len()
sorted()  ---> 排序，返回的结果是列表类型
tuple()  ---->强制转换为元组类型

元组自带的函数：
index()  返回的是位置
count()  返回的是个数


拆装包：
x,*y=（3,1,7,9）
print(y)     装包
print(*y)    拆包


'''

t2 = (4,5)+(1,2)

print(t2)


t3 = (3,4)*2

print(t3)

print(t2 is t3)

print(3 in t3)

print(tuple(sorted(t2)))
 
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

字典(dict)

# dicthionary 字典
'''
字典：
 特点：
 1.符号：{}
 2.关键字：dict
 3.保存的元素是：key:value   一对

 列表          元组          字典
 []             ()          {}

 list        tuple        dict
 element      element          key：value

[].append(8)

'''

# 定义

dict1 = {}    # 空字典

dict2 = dict()  # 空字典     list1 = list() 空列表 tuple = tuple() 空元组

dict3 = {'ID':'023283598269','name':'lucky','age':18}

# dict4 = dict(('name','lucky'))  #{'name':xxxx,'lucky':xxxx}
# print(dict4)

dict4 = dict([('name','lucky'),('age',19)])
print(dict4)

dict5=dict([(1,2),(3,4)])
print(dict5)


# list 可以转成dict 但是前提：列表中的元素要成对出现

# 字典的增删改查：

# 增加：格式：dict6[key]=value
# 特点：按照上面的格式，如果再字典中存在同名的key，则发生覆盖（后面的值覆盖前面的值）
#     如果没有同名的key，则是实现添加功能（key:value添加到字典中）
dict6 = {}


dict6['brand']='huawei'

print(dict6)   # {'brand':'huawei'}

dict6['brand']='mi'

print(dict6)

dict6['type']='p30 pro'

dict6['price']='9000'

dict6['color']='黑色'

print(dict6)


'''
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

print('--------欢迎来到智联招聘用户注册界面---------')

# 模拟数据库
database = []

while True:
   username = input('输入用户名：')
   password = input('输入密码：')
   repassword = input('输入确认密码:')
   email = input('输入邮箱：')
   phone = input('输入手机号：')


   # 定义一个字典
   user = {}
   # 将信息保存到字典中
   user['username']=username
   if password==repassword:
      user['password']=password
   else:
      print('两次密码不一致！！！重新输入')
      continue

   user['email']=email
   user['phone']=phone

   # 保存到数据库 
   database.append(user)

   answer = input('是否继续注册？（y/n）')
   if answer!='y':
      break

print(database)
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

'''

增加元素(key:value):
dict[key]=value   ---->{key:value}

特点：key 在字典中是唯一的，value值不唯一
{'name':'tom','name':'aaa'}       错误定义
{'张三:100,'李四':100,'王五':100}       正确定义


增加元素对比：
list1 = []
list1.append(element)

dict1 ={}
dict1[key]=value

修改：
list1[index]=newelement

dict1[key]=newvalue

查询元素：
list1[index]   ---> element

dict[key] ---> value

取值：字典都是根据key获取value值

'''

list1 = [3,5,7,8]
print(list1[2])

dict1 = {'1':'张三','2':'李四','5':'王五'}

print(dict1['2'])   # 字典中找元素根据key找

dict2 = {'张三':100,'王五':89,'李四':98}

# 尝试对字典遍历

for i in dict2:
   print(i)

# 单独遍历字典的结果是：字典的key 

# 字典里面的函数：
#           items() 将字典的键值对转成列表的形式



#  value()
#  keys()

print(dict2.items())

for i in dict2.items():
   print(i)    #  ('zhangsan',100)


# 考试分数大于90分的人

for key,value in dict2.items():
   if value>90:
      print(key)


# 求所有学生考试成绩的平均分
for score in dict2.values():
   print(score)

scores = dict2.values()

totle = sum(scores)
avg = totle/len(scores)

print(avg)

# keys():获取字典中的所有key键

names = dict2.keys()
print(names)

for name in dict2:
   print(name)

'''
# 1.根据key获取值，如果key在字典中美哟有存在则报出KeyError
   dict[kkey]=value
   2.字典的内置函数：
   get(key)  ---> value  如果取不到值则不会报错，返回none
   get(key,default)  --> value 如果能取到值则返回字典中的值，如果取不到则返回default的值
   

   '''
# print(dict2['赵飞'])
print(dict2.get('赵飞',99))
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

# 增加 改 查 （key）删 
# 删除：
list1 = [3,7,9,0]

del list1[1]
print(list1)

dict1 = {'张三':100,'李四':89,'王五':99,'赵六':99.5}
# 字典的内置函数：删除
# 没有remove
# pop(key[,default])  ----> 根据key删除字典中的键值对，只要删除成功了，返回值就是删除成功的键值对的值

result = dict1.pop('李四')
print(result)

print(dict1)

result = dict1.pop('张晓丹','字典中没有此键')
print('=======>',result)


print("********")
# popitem():随机删除字典中的键值对（一般式是从末尾删除的）

dict1 = {'张三':100,'李四':99,'王五':89,'赵六':99.5}
result = dict1.popitem()
print(result)

print(dict1)

# clear() 同列表的删除 清空
dict1.clear()
print(dict1)

'''
删除：
del dict[key]

dict.pop(key[,default])

dict.clear()

'''

'''
其他内置函数：
update()    []+[]  合并操作
fromkeys(seq[,default])  ----> 将seq转成字典的形式 如果没有指定的value则用None代替


'''

# dict1 = dict1+dict2    报错的
# print(dict1)

dict1 = {0:'tom',1:'jack',2:'lucy'}

dict2 = {0:'lily',4:'ruby'}

result = dict1.update(dict2)
print(dict1)

list1 = ['aaa','bbb','cccc']
new_dict = dict.fromkeys(list1,10)
print(new_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

集合(set)

# 具有不重复特点
list1 = [3, 4, 5, 2, 2, 4, 5, 8, 2, 9, 0, 1]

# 声明集合： set

s1 = set()  # 创建空集合，只能使用set()

s2 = {1, 3, 7}  # 字典：{key:value,key:value,........}
# 集合：{元素1,元素2,元素3......}
print(type(s1))
print(type(s2))

# 应用：如果将一个列表快速去重 set()
s3 = set(list1)  # {1,2,3,4,5,.....}
print(s3)

# 增删改查：

# 1.增加 s1 = set()
s1.add('hello')

s1.add('小猪佩奇')

print(s1)

# add() 添加一个元素
# update() 添加多个元素

t1 = ('林志玲', '言承旭')
s1.update(t1)  # 无序添加

print(s1)

s1.add(t1)  # 让t1以一个元素的形式添加
print(s1)

# 2. 删除  remove 如果元素存在则删除，不存在则报错keyError	pop  随机删除（一般删除第一个元素）clear

s1.remove('言承旭')

print(s1)

# s1.remove('道明寺')
# print(s1)

s1.pop()
print(s1)

s1.pop()
print(s1)

s1.clear()  # 清空
print(s1)

# discard()  类似remove() 但是移除没有的元素时不会报错

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

'''
1.产生10个1~20的随机数，去除里面的重复项
2.键盘输入一个元素，将此元素从不重复的集合中移除
'''
# 小案例
import random

list1 = []

set1 = set()

for i in range(10):
    ran = random.randint(1, 20)
    list1.append(ran)

    set1.update(list1)

print(list1)
print(set1)

num = input('输入一个数字：')

set1.discard(num)   # 删除num，num不存在不报错

print('删除之后的结果：', set1)

# 符号：
# 不支持（+ *）- & |
set2 = {1, 3, 2, 4, 5}
set3 = {1, 3, 2, 4, 5, 8, 6, 7}

set4 = set3 - set2  # 差集 difference()
print(set4)

set4 = set3.difference(set2)
print(set4)

# & 交集  intersecthion()

set5 = set2 & set3
print(set5)

set6 = set2.intersection(set3)
print(set6)

# | 并集  union() 联合

set8 = set3 | set2

print(set8)

set9 = set3.union(set2)
print(set9)

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

# 可变 和 不可变

# 不可变：对象所指向的内存中的值是不可以改变的(内存地址存的值是不可以改变的)

# 不可变的类型： int str float 元组tuple

num = 10

s1 = 'abc'
print(id(s1))

s1 = 'abcd'
print(id(s1))

t1 = (3, 5)
print(id(t1))

t1 = ('3,5,6')
print(id(t1))

# 可变的：对象所指向的内存中的值是可以改变的（内存地址存的值是可以改变的）

# 可变的类型：字典 dict		列表 list 		集合 set

list1 = [1, 2, 3, 4]
print(list1, id(list1))

list1.pop()
print(list1, id(list1))

dict1 = {1: 'aa', 2: 'bb'}
dict1.pop(1)
print(dict1, id(dict1))

print('*********集合********')
set1 = {1, 3, 4, 5, 7}
print(id(set1))
set1.pop()
print(set1, id(set1))

set1.discard(5)
print(set1, id(set1))

fset = frozenset(set1)
print(fset, id(fset))

fset = frozenset({3, 5})
print(fset, id(fset))

'''
140605822186360
140605822240672
140605827701320
140605822240840
[1, 2, 3, 4] 140605552974472
[1, 2, 3] 140605552974472
{2: 'bb'} 140605822233840
*********集合********
140605557303112
{3, 4, 5, 7} 140605557303112
{3, 4, 7} 140605557303112
frozenset({3, 4, 7}) 140605557303336
frozenset({3, 5}) 140605558066312
'''

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

字符串(string)

#字符串：


s1 = 'abc'				#声明字符串
s2 = "abc"				#声明字符串
s3 = '''				
abc
'''						#声明字符串  三引号可以保留格式

print(id(s1),id(s2),id(s3))    #测地址   ''' 三引号占用的内存空间与单双引号的不同（前提是三加引号有换行/因为三引号需要保留格式）

print(s1 == s2)   # 等号 比较的是内容
print(s1 is s2)   # is 比较的是地址

print(s2 == s3)    # s2 与 s3 的内容是不一样的，s3 有换行
print(s2 is s3)


s1 = input('请输入：')			#input输入的是字符串 #abc
s1 = input('请输入：')			#input输入的地址不同	#abc

print(s1 == s2)										#True
print(s1 is s2)										#False 注意（常量赋值is是True，input输入做了底层处理所以最后的地址是不一样的）


#字符串的运算符：+ *


s3 = s1+s2		# + 相当于拼接符
s4 = s1 * 5		# * 倍数

print(s3)
print(s4)


# in 在...里面（运算符）

name = 'steven'

result = 't' in name	# 返回值是布尔类型 Ture False
print(result)


#not in 	没有在...里面


result = 't' not in name	# 返回值是布尔类型 Ture False
print(result)


#  %  字符串的格式化

print('%s说：%s'%(name,'大家好好学习天天向上！'))


# r 保留原格式	有r发生转义	没r则发生转义（例如：转义字符		\'	）

print('%s说：\'哈哈哈！\''%name)   # 输出	Steven说：'哈哈哈！'
print(r'%s说:\'哈哈哈！\''%name)   # 输出		steven说：\'哈哈哈！\'

#[]  [:]

filename = 'picture.png'

# 位置都是从0开始的，位置也会称为下标或者索引
print(filename[5])	# 通过 [] 可以结合位置 获取字母 特点：只能获取一个字母

# range(1,10)  --类似-->	 [1:10]

print(filename[0:7])	# 包前不包后

print(filename[3:7])	# 截取字符串

#负数
print(filename[8:-1])

print(filename[:-2])

print(filename[-1:])

print(filename[-5:-1])


#[::-1]	倒叙

print(filename[::-1])	# 逆序

str1 = 'abcdefg'

print(str1[-1:-5:-1])   # gfed

print(str1[5:0:1]) # 输出空

print(str1[:]) # 一个冒号 什么都不写 从 0 开始 到 末尾结束
 
#练习 	Hello world

# str[start:end:方向和步长]

str2 = 'Hello world'

print(str2[-1:-6:-1])

print(str2[0:5:1])

print(str2[0:5])

print(str2[::-1])

print(str2[-7:-10:-1])

#

print(str2[::2])	# 步长为 2
print(str2[::-2]) 	#步长为 2 



# 字符串的内建函数： 声明一个字符串，默认可以调用内建函数

# 第一部分： 大小写相关的
# capitalize()	title()	 upper()	isupper()	lower()	islower()

message = 'fanxinru is a beautiful girl!'

msg = message.capitalize()  # 将字符串的第一个字符转换成大写的标识形式
print(msg)

msg = message.title()  # 返回每个单词的首字母大写的字符串
print(msg)

result = message.istitle()  # 返回的结果是布尔类型的，Ture	false
print(result)
msg = message.istitle()  # is开头的是判断
print(msg)

msg = message.upper()  # 将字符串全部转为大写的形式
print(msg)

result = msg.lower()  # 将大写转为小写
print(result)

# 案例：验证码案例

s = 'QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm0987654321'

print(len(s))  # 求字符串长度 len(str),返回值是一个整型的数值

# 四个随机数
code = ''

import random

# # IndexError: string index out of range    例如也会报错： s = 'abc'    prrint(s[3])
# # Index: 0~len(s)-1    0~61
for i in range(4):
    ran = random.randint(0, len(s) - 1)
    # print(ran)

    # print(len[ran])
    code += s[ran]  #

print('验证码：' + code)

# 提示用户输入验证码

user_input = input('请输入验证码：')

if user_inputlower() == codelower():
    print('验证码输入正确！')
else:
    print('验证码输入错误！')

    
# 字符串内建函数： encode		编码		decode		解码

# 编码 ：

msg = '上课认真听讲！'

'''
gbk 中文		gb2312	简体中文		unicode

'''

result = msg.encode('utf-8')

print(result)

# 解码
m = result.decode('utf-8')
print(m)


# 查找相关的，替换

# find()	rfind	lfind() 	index()		rindex()	replace()	

s1 = 'index lucy lucky goods'

result = 'R' in s1
print(result)


position = s1.find('R')		# 返回值是-1则代表没有找到
print(position)

position = s1.find('l')		# 如果可以找到则返回字母第一次出现的位置
print(position)


# find('要查找的字符'，start,end)
p = s1.find('o',position+1,len(s1)-5)		# 也可以指定开始位置查找
print(p)


# https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png

url = 'https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png'

p = url.rfind('/')		# right find 从右边开始找‘/’
print(p)

filename = url[p+1:]
print(filename)

# 找扩展名
p = url.rfind('.')
kz = url[p+1:]
print(kz)


'''

index(str,beg=0,end=len(string))
跟find()方法一样，只不过如果str不在字符串中会报一个异常

'''

# p = 'hello'.index('x')

# print(p)		# 会报异常46行 


# 替换

s1 = 'index lucy lucky goods'
# replace(old,new,[max])
s2 = s1.replace(' ','#')

print(s2)

s2 = s1.replace(' ','')
print(s2)



# 字符串内建函数 ： encode  编码		decode	编码

#	编码 ： 中文 	（网络中使用）

# msg = '上课了！认真听课！'	#中文的

# #	gbk 中文 	gb2312 简体中文	Unicode

# result = msg.encode('utf-8')

# print(result)

# # 解码
# m = result.decode('utf-8')
# print(m)



# 字符串内建函数： startswith()	endswith()	返回值都是布尔内型ture false

# startswith判断是否是以xxx开头的，或者 endswith判断是否是以xxx结尾的

# 应用 ： 文件上传	只能上传图片（jpg,png,bmp,gif）

filename = '笔记.doc'

result = filename.endswith('doc') 				#filename是否是以doc结尾

print(result)



s = 'hello'  
result = s.startswith('he')
print(result)


# 文件上传 只能上传图片(jpg,png,bmp,gif)


# \n 换行	\r 回车 保留原格式		\'		\"		\t 四个空格即一个制表位		\\
while True:
	path = input('请选择文件:')		# C:\Users\Lenovo\Desktop\简历

	# 分析 ： 要上传的文件的路径path--->文件名---->通过文件名在判断是否是图片类型
	p = path.rfind('\\')

	filename = path[p+1:]  # 通过切片截出文件名

	# 判断是否是图片类型？

	if filename.endswith('jpg') or filename.endswith('png') or filename.endswith('bmp'):
		print('是图片允许上传！')
		break
	else:
		print('不是图片格式，只能上传图片！')
    
    
    
# isalpha()	是否是字母	isdigit() 是否是数字


s = 'abcd6'
result = s.isalpha()
print("reslut=",result)


s = '6688'
result = s.isdigit()
print(result)



sum = 0
for i in range(3):
	num = input('请输入数字：')

	if num.isdigit():
		num = int(num)

		sum+=num
print('sum=',sum)





# i = 1
# sum = 0
# while i<=3:
# 	num = input('请输入数字：')

# 	if num.isdigit():
# 		num = int(num)
# 		sum+=num

# 		print('第{}个数字累加成功！'.format(i))

# 		i+=1
# 		print(sum)	
# 	else:
# 		print('不是数字！')



# # join():  '-'.join('abc')    将abc用-连接构成新的字符串

# new_str = '-'.join('abc')
# print(new_str)


# # python 列表  list = ['a','b','c']   数组
# list1 = ['a','v','o','9']
# result = ''.join(list1)
# print(result)


# result = ' '.join(list1)
# print(result)


# # lstrip 	rstrip 		strip			去除空格

# s = '   hello   '
# s = s.lstrip()
# print(s+'8')

# s = s.rstrip()
# print(s+'8')

# s = s.strip()
# print(s+'8')


# split()  分割字符串，将分割后的字符串保存到列表中

s = 'hello wlord hello kitty'
result = s.split(' ',2)   # 表示按照空格作为分隔符，分割字符串2次
print(result)

n = s.count(' ')	# count(args)	求字符串中指定args的个数
print('个数：',n)

# 求s中s的个数
s = 'fhauifhqf,asfjasf;faaffsasfs'
result = s.count('s')
print(result)
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404

数字（int, float,bool,complex(复数)）

python中的数字有四种：

int、

float、

boolean（bool是int的子类型）

complex（复数）：4 + 3j

a, b = 4, 2
c, d = 9, 2

# 取余 
print(c % d)  # 1

# 除法，得到一个整数
print(c // d)  # 4

“”“内置的函数type()可以查询变量所指的对象类型”“”
print(type(a))  # <class 'int'>


# type和isinstance区别：
'''
type : 不会认为子类是一种父类
isinstance: 会认为子类是一种父类
'''
class A:
	pass

class B(A):
	pass

e = isinstance(A(), A)
print(e)	# True
f = type(A()) == A
print(f)	# True

g = isinstance(B(), A)
print(g)	# True
n = type(B()) == A
print(n)	# false
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

函数

import random


def generate_random():
    for i in range(10):
        ran = random.randint(1, 20)
        print(ran)


print(generate_random)    # 打印函数名

# 调用：函数名()  找到函数并执行函数体里的内容
print('-------1-------')
generate_random()

print('-------2-------')
generate_random()

# 定义方式：
def add(name,*args):         # argument 参数
    print(name,args)
    sum = 0
    if len(args) > 0:
        for i in args:
            sum += i
        print('%s累加和是：sum:%s'%(name,sum))
    else:
        print('没有元素可计算！！')


# 调用：
# add()       # 空元组
add(1)  #
add('菲菲',2,4)
add(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
24
25
26
27
28
29
30
31
32
33
34
35
36
37

带参函数

# 函数：带参数的
'''
定义：
def 函数名(参数,参数....)
    函数体
调用：
    pass
'''
# 求随机数的函数：
# alt+enter 快速提醒/提示
import random


def generate_random(number):        # 形参：形式上的参数,接收、占位的
    for i in range(number):
        ran = random.randint(1,20)
        print(ran)


print(generate_random)

# 调用
generate_random(5)    # 实参：实际的参数 具体的值

generate_random(8)

# 求加法的函数：
def add(a,b):
    result = a+b
    print('和是：',result)

# 调用:
add(1,2)

add(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
24
25
26
27
28
29
30
31
32
33
34
35

匿名函数

# 匿名函数：
# 匿名函数作为参数：
def func(x, y, func):
    print(x, y)
    print(func)
    s = func(x, y)
    print(s)


# 调用func：
func(1, 2, lambda a, b: a + b)

list1 = [1, 3, 5, 6, 8, 9]
m = max(list1)

print('列表的最大值是：', m)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 匿名函数作为参数
def func(x, y, func):
    print(x, y)
    print(func)
    s = func(x, y)
    print(s)


# 调用func
func(1, 2, lambda a, b: a + b)

# 匿名函数与内置函数的结合使用：
# max   sorted  zip

# max
list1 = [3, 5, 8, 9, 0]
m = max(list1)
print('列表中的最大值是：', m)

list2 = [{'a': 10, 'b': 20}, {'a': 18, 'b': 11}]

m = max(list2, key=lambda x: x['a'])
print('列表中的最大值是：', m)

# 匿名函数：lambda
# 对列表中的奇数进行加1操作
# map()
list1 = [1, 3, 2, 6, 9, 0, 7, 5]
result = map(lambda x: x if x % 2 == 0 else x + 1, list1)
print(list(result))
# 类似上例
for index, i in enumerate(list1):
    if i % 2 != 0:
        list1[index] = i + 1

print(list1)

# reduce():对列表中的元素进行加减乘除运算的函数
# 1.
from functools import reduce

tuple1 = (2, 3, 5, 7, 9, 1)

result = reduce(lambda x, y: x + y, tuple1)

print(result)

# 2.
tuple2 = (1,)

result = reduce(lambda x, y: x + y, tuple2, 10)

print(result)

# filter()
students = [
    {'name': 'tom', 'age': 29},
    {'name': 'lily', 'age': 18},
    {'name': 'lucy', 'age': 23},
    {'name': 'mark', 'age': 15}
]

# 找出年龄大于20岁的所有学生
result = filter(lambda x: x['age'] > 20, students)
print(list(result))
# sorted
# 按照年龄从小到大排序
students = sorted(students, key=lambda x: x['age'],reverse=True)
print(students)
'''
总结：
max()
min()
sorted()
map() 统一对列表中的元素进行一些操作
reduce()
filter() 进行过滤
'''
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

递归函数

# 递归函数：函数自己调用自己
# (先传递，再归回)
'''
普通函数：def func():
            pass
匿名函数：lambda 参数：返回结果
递归函数：普通函数的一种表达形式
    特点：1.递归函数必须设定终点
         2.通常会有一个入口
'''

def sum(n):                     # 入口（ n ）
    if n == 0:                  # 出口(终止条件)
        return 0
    else:
        return n + sum(n-1)    # 调自己sum


result = sum(5)
print(result)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

应用

# 应用
def login(username, password):
    # 相当于数据库注册的用户名和密码
    uname = 'admin123'
    pwd = '111111'
    for i in range(3):
        if username == uname and password == pwd:
            print('登录成功！！！')
            break
        else:
            print('登录失败！！！')
            input('请输入用户名：')
            input('请输入密码：')
    else:
        print('账户锁定！')


# 调用：

username = input('请输入用户名：')
password = input('请输入密码：')

login(username, password)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 找出列表的最大值：

# 自己封装一个最大值函数
def max(iterable):
    max=iterable[0]
    for i in iterable:
        if i>max:
            max=i
    print('最大值是:',max)

# 调用 测试是否可以找到最大值
list1=[1,2,3,45,5,53,326,88,9]
max(list1)

tuple1 = (1,24,5,6,2,78,0,76,9)
max(tuple1)


#

print(type(tuple1))   # 查看是什么类型

# 判断是不是什么类型：isinstance(变量,类型关键字)
print(isinstance(2,int))   # 返回值是布尔类型的False.True

if isinstance(tuple1,tuple):
    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
25
26
27

# 默认参数：key = value

def add(a, b=10):  # 默认b=10
    result = a + b
    print(result)


# 调用
add(4)

add(4, 7)  # a=4  b=7 此时的7就会覆盖b原来的值


def add1(a, b=10, c=4):
    print(a, b, c)
    result = a + b + c
    print(result)


# 调用：
add1(1, 5)  # 给b赋值成功 把b=5

# 给c赋值而不是b
add1(2, 6)  # 默认6赋值给了b

add1(2, c=6)  # a=2 b=10 c=6 如果想将6赋值给需要结合key使用

students = {'001': ('蔡徐坤', 21), '002': ('王俊凯', 20), '003': ('易烊千玺', 19)}


def print_boy(name, persons):
    if isinstance(persons, dict):
        values = persons.values()
        print(values)
    for name, age in values:
        print('{}的年龄是：{}'.format(name, age))


# 调用
print_boy('蕊蕊', students)


def func(**kwargs):  # 装包（定义函数时**装包）
    print(kwargs)


# 调用：
func()
func(a=1)
func(a=1, b=4)
func(a=1, b=4, c=3)  # 关键字参数

dict1 = {'001': 'python', '002': 'java', '003': 'c语言', '004': 'go语言'}


def func(**kwargs):
    print(kwargs)


# func(dict1)  报错

func(**dict1)  # ** 只应用在字典前面  拆包（调用函数时**拆包）


def bb(a, b, *c, **d):
    print(a, b, c, d)


# 調用
bb(1, 2)  # 1 2 () {}

bb(1, 2, x=100, y=200)  # 1 2 () {'x':100,'y':200}


# 练习
def func(a, *args):
    print(a, args)


# 调用
func(2, [1, 2, 3, 4], 'hello', 5)  # 2 ([1,2,3,4],'hello',5)

func(2, (1, 2, 3, 4), 7)  # 2 ((1,2,3,4),7)


def func(a, *args, **kwargs):
    print(a, args, kwargs)


# 调用
t = (1, 2, 3, 4)
func(1, t)
func(1, *t)  # 1 (1, 2, 3, 4) {}

l = [2, 5, 8]
func(1, l)  # 1 ([2, 5, 8],) {}
func(1, *l)  # 1 (2, 5, 8) {}

dict1 = {'1': 'a', '2': 'b', '3': 'c'}
func(1, 2, 5, 8, dict1)  # 1 (2, 5, 8, {'1': 'a', '2': 'b', '3': 'c'}) {}
func(1, 2, 5, 8, **dict1)  # 1 (2, 5, 8) {'1': 'a', '2': 'b', '3': 'c'}


def func1(name, *args):
    if len(args) > 0:
        for i in args:
            print('{}学过了{}'.format(name, i))
    else:
        print('没有学过任何编程课程！！')


courses = ['python', 'html', 'mysql']
func1('坤坤', *courses)
func1('坤坤', courses)


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

总结有参数的函数：

1. 普通参数

def func(name,age):
	pass

func('aa',18)---->形参与实参的个数要一致

2. 可变参数

A.  
def func(*args):
    pass
    
func()  ----> 函数调用时，实参的个数可以没有也可以多个  *不能是关键字参数
func(4)
func(5,'h')

B.
def func(**kwargs):
    pass
    
func(a=1,b=2)  ----> 函数调用时，实参的个数可以没有也可以多个  **必须是关键字参数

C.
def args(*args,**args):
    pass
    
list1 = [1,3]
dict1 = {'1':'a','2':'b'}
func(*list1,**dict1)  # func(1,3,'1'='a','2'='b'）拆包

D. 混用
def func(name,*args,**kwargs):
    pass
    
func('tom') ----> 必须赋值

       3. 默认值+关键字

def func(name,age=18):
    pass
    
func('tom') ---> tom 18

func('tom',age=20) ---> 关键字赋值
     
'''
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

返回值说明：将函数中的运算结果通过 return 关键字 ’扔‘出来

def add(a, b):
    result = a + b

    print(result)
    return 'hello','world'


# 调用函数
x,y = add(2, 7)
print(x,y)          # 9 hello world

1
2
3
4
5
6
7
8
9
10
11

return 返回值

1.return后面可以跟一个参数 接受的时候x=add(1,2)

2.return 后面也可以跟多个参数，如果是多个参数则底层会将多个参数先放在一个元组中，将元组作为一个整体返回

3. 接受的时候也可以是多个：return’hello’,‘world’---->x=hello y=world
   ‘’’

# 案例(函数嵌套调用)：
islogin = False

def add_shoppingcart(goodsName):
    global islogin
    if islogin:
        if goodsName:
            # 登录的
            print('成功将{}加入购物车中!'.format(goodsName))
    else:
        answer = input('用户没有登录!是否登录用户？（yes/no）')
        if answer == 'yes':
            # 登录
            username = input('输入用户名：')
            password = input('输入密码：')

            # 调用login
            islogin = login(username,password)  # 在一个函数中调用另一个函数
            print('islogin:',islogin)
        else:
            print('很遗憾！不能添加任何商品！')

def login(username,password):
    if username == 'lijiaqi' and password == '123456':
        print('登录成功！')
        return True
    else:
        print('用户名或密码错误')
        return False
# 调用函数： 添加商品到购物车中
username = input('输入用户名：')
password = input('输入密码：')

islogin = login(username,password)
add_shoppingcart('阿玛尼唇釉')
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

# 函数嵌套调用说明：
def a():
    print('AAAAAA')


def b():
    a()
    print('BBBBBB')


def c():
    b()
    print('CCCCCC')


# 调用
c()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 函数嵌套调用02
# 函数综合应用：
import random

# 定义生成验证码函数
def generate_checkcode(n):
    s = '0987654321qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM'
    code = ''
    for i in range(n):
        ran = random.randint(0, len(s) - 1)  # randint 包前包后
        code += s[ran]
    return code

# 定义登录函数
def login():
    username = input('输入用户名：')
    password = input('输入密码：')
    # 得到一个验证码
    code = generate_checkcode(5)        # 函数嵌套调用
    print('验证码是：',code)
    code1 = input('输入验证码：')
    # 验证
    if code.lower()==code1.lower():
        # 验证码输入正确
        if username=='lijiaqi' and password=='123456':
            print('用户登录成功！')
        else:
            print('用户名或密码错误！')
    else:
        print('验证码输入错误！')


login()
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

# # global 变量范围问题（global 声明全局变量的关键字）
# # 局部变量  全局变量
#
# # 声明在函数外层的是全局变量，所有函数都可以访问。
# # 声明在函数内层的是局部变量，仅限于函数体内可以访问。
#
# # A.
# name = '月月'
#
#
# def func():
#     s = 'abcdefghqlmn'
#     s += 'x'
#     print(s,name)
#
#
# # B.
# def func1():
#     global name  # 不修改全局变量，只是获取打印。但是如果要发生修改全局变量，则需要再函数内部声明：global 变量名
#     print(name)
#     name += '会弹吉他的女孩！！'  # 不加 global name 会报错 函数内部的可以随便修改赋值，但是全局的变量就不能再函数体中修改
#     print('修改后的name:',name)
#
#
# # C.
# def func2():
#     name = '小月月'
#     name += '会弹吉他的'
#     print(name)

# func()
# func1()
# func2()
#
# # D.局部和全局
# #   全局变量如果是不可变在函数中进行修改需要添加global 关键字
# #   如果全局变量是可变的，在函数中修改的时候就不需要添加 global
name = '月月'
list1 = [1, 2, 3, 4]


def func():
    name = '瑞瑞'
    print(name)
    print(list1)


def func1():
    global name
    print(name)
    name += '真漂亮！'
    print(name)

    list1.append(8)
    print(list1)


func1()  # 月月    月月真漂亮！  [1, 2, 3, 4, 8]
func()  # 瑞瑞    [1, 2, 3, 4, 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
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

# 内部函数（函数的嵌套）：
def func():
    # 声明变量
    n = 100  # 内部变量
    list1 = [6, 2, 0, 8]  # 内部变量

    # 声明内部函数：
    def inner_func():
        nonlocal n  # 不用global 用nonlocal
        for index, i in enumerate(list1):
            # index = 0 ----- i = 6
            list1[index] = i + n

        list1.sort()
        # 修改n变量
        n += 101

    # 调用内部函数
    inner_func()
    print('打印老大n：', n)

    print('打印老二list1:', list1)


# 调用func
func()

# 内部函数
'''
特点：
1.  可以访问外部的变量
2，  内部函数可以修改外部函数的可变类型的变量 不如：list1
3，  内部函数修改全局的不可变变量时，需要在内部函数声明 global 变量名
     内部函数修改外部函数的不可变量时，需要在内部函数中声明 nonlocal 变量名
4，  locals() 查看本地变量有哪些，以字典的形式输出
    global()  查看全局变量有哪些，以字典的形式输出（里面会有系统的键值对） 
'''
a = 100

print(globals())


def func():
    b = 99

    def inner_func():
        global a
        nonlocal b
        c = 80
        # 尝试修改
        a += 2
        b += 1
        c += 20
        print(a, b, c)

    inner_func()
    # 使用locals()内置函数查看。可以看到在当前函数中声明的内容有哪些
    # locals()时一个字典。key: value
    print(locals())


# 调用函数：
func()
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

# 闭包
# 在函数中提出的概念
'''
条件：
1.  外部函数中定义了内部函数
2.  外部函数是有返回值的
3.  返回值是：内部函数名
4.  内部函数引用了外部函数的变量

格式：
def 外部函数():
    ...
    def 内部函数():
        ...
    return()

'''


# 示例1：
def func():             # define
    a = 100

    def inner_func():
        b = 99
        print(a, b)

    print(locals())
    return inner_func


x = func()    # func() /函数名() :是调用的意思  # 1.先调用  2.再把调用的值赋值给x
x()
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.
def func(a, b):
    c = 10

    def inner_func():
        s = a + b + c
        print('相加和是：', s)

    return inner_func


ifunc = func(4, 6)  # ifunc就是inner_func     ifunc=inner_func
# 调用返出来的内部函数
ifunc()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 闭包
# 示例3
def func(a, b):
    c = 10   # 不可变的

    def inner_func():
        s = a + b + c
        print('相加和是：', s)

    return inner_func


ifunc = func(6, 8)  # <function func.<locals>.inner_func at 0x000001DF88BC0158>
ifunc1 = func(2, 8)  # <function func.<locals>.inner_func at 0x000001DF88BC01E0>
# 分配了的地址不同

print(ifunc)
print(ifunc1)

ifunc()
ifunc1()
# 相加和是： 24
# 相加和是： 20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 闭包总结：
'''
1.  闭包似优先了变量，原来需要类对象完成的工作，闭包也可以完成。
2.  由于闭包引用了外部函数的局部变量，所以外部函数的局部部变量没有及时释放，占用内存
3.  闭包的好处，使代码简洁，便于阅读代码。
4.  闭包使理解装饰器的基础。
'''


def func():
    a = 100

    def inner_func1():
        b = 10
        s = a + b
        print('s:',s)

    def inner_func2():      # define
        inner_func1()       # 调用inner_func1
        print('---->inner_func2:', a)
        return 'hello'

    return inner_func2      # 0x000001EE186301E0


ifunc = func()      # innerfunc2=ifunc
print(ifunc)
ifunc1 = ifunc()
print(ifunc1)
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

# 闭包的例子：计数器
def generate_count():
    container = [0]

    def add_one():
        container[0] = container[0] + 1
        print('当前是第{}次访问！'.format(container))

    return add_one


count = generate_count()
count()
count()
count()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 装饰器
# def func(number):
#     a = 100
#
#     def inner_func():
#         nonlocal a
#         for i in range(number):
#             a += 1
#         print('修改后的a:', a)
#
#     return inner_func
#
#
# f = func(5)
# f()


# 定义一个装饰器
def decorate(func):
    a = 100
    print('wrapper外层打印测试')

    def wrapper():
        func()
        print('----->铺地板')
        print('----->刷漆', a)
        print('----->撞门')

    print('wrapper加载完成！！！')
    return wrapper


# 使用装饰器
@decorate
def house():
    print('我是毛坯房....')


house()
'''
1. house 被装饰函数
2. 将被装饰函数传给装饰器decorate作为参数
3. 执行decorate函数
4. 将返回值又赋值给 house

'''

print(house)
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

# 装饰器
# 登录校验：
import time01


def decorate(func):
    def wrapper(*args, **kwargs):  # {‘class’：2003}
        print('正在登录校验中。。。。')
        time01.sleep(2)
        print('--------校验完毕--------')
        # 调用原函数
        func(*args, **kwargs)

    return wrapper


@decorate
def f1(n):  # f1 = wrapper
    print('-----------f1----------', n)


# 调用
f1(5)  # 调用wrapper


@decorate
def f2(name, age):
    print('------------f2-----------', name, age)


# 调用
f2('Sue Jone', 20)


@decorate
def f3(students, clazz='2003'):
    print('{}班的学生如下：'.format(clazz))
    for stu in students:
        print(stu)


students = ['lily', 'tom', 'lucy']
f3(students, clazz='2002')


@decorate
def f4():
    print('-----------f4')


f4()
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

# 装饰器（多层）
'''
如果装饰器是多层的，谁距离最近优先使用哪个装饰器
'''


def zhuang1(func):
    print('--------->1 start')

    def wrapper(*args, **kwargs):
        func()
        print('铺地板')

    print('---------->1 end')
    return wrapper


def zhuang2(func):
    print('-------->2 start')

    def wrapper():
        func()
        print('刷漆')

    print('-------->2 end')
    return wrapper


@zhuang2
@zhuang1
def house():
    print('我是毛坯房....')


house()
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

# 装饰器  带参数的
'''
带参数的装饰器是三层的
最外层的函数负责接受装饰器参数
里面的内容还是原装饰器的内容
'''


def outer(a):  # 第一层：负责接受装饰器给的参数
    def decorate(func):  # 第二层：负责接受函数
        def wrapper(*args, **kwargs):  # 第三层：负责接收函数的参数的
            func(*args)
            print('---->铺地砖,我铺了{}块地砖'.format(a))

        return wrapper  # 返出来的是：第三层

    return decorate  # 返出来的是：第二层


@outer(10)
def house(time):
    print('我是{}拿到钥匙的，是毛坯房....'.format(time))


house('2020.9.16')
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

# 装饰器
# 开发：登录验证
import time01

islogin = False


# 定义一个扽登录函数：
def login():
    username = input('请输入用户名：')
    password = input('请输入密码：')
    if username == 'admin' and password == '123456':
        return True
    else:
        return False


# 定义一个装饰器，进行付款验证
def login_required(func):
    def wrapper(*args, **kwargs):
        global islogin
        print('--------付款-------')
        # 验证用户是否登录
        if islogin:
            func(*args, **kwargs)
        else:
            # 跳转至登录页面
            print('用户没有登录，不能付款！')
            islogin = login()
            print('result', islogin)

    return wrapper


@login_required
def pay(money):
    print('正在付款，付款金额是{}'.format(money))
    print('付款中.....')
    time01.sleep(2)
    print('付款成功！')


# 调用
pay(10000)
pay(8000)
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

模块

# 模块
'''
在python中，模块是代码组织的一种方式，把功能相近的函数或者类放到一个文件中，一个文件（.py）就是一个模块（module）
模块名就是文件名去掉后缀.py。
优点：
 1.提高代码的可复用、可维护性。一个模块编写完成后，可以很方便的在其他项目中导入
 2.解决了命名冲突，不同模块中相同的命名不会冲突。

 1）自定义模块    calculate
 2）使用系统一些模块

导入模块
 1.import 模块名
模块名.变量名   模块名.函数   模块名.类
 2.from 模块名 import 变量|函数|类
 在代码中可以直接使用变量|函数|类
 3.from 模块名 import *
   导入该模块中的所有内容
   但是如果想限制获取的内容，可以在模块中使用__all__=[使用*需要访问到的内容]
 4.无论是import还是from的形式，都会将模块内容进行加载
 如果不希望其进行调用。就会用到__name__
 在自己的模块里面__name__叫：__main__
 如果在其他模块中通过导入的方式调用的话：__name__:模块名


'''

list1 = [2, 4, 5, 6, 7, 5]
# # 导入模块  import 模块名
# import calculate
#
# # 使用模块里函数   模块名.变量  模块名.函数  模块名.类
# result = calculate.add(*list1)
# print(result)
#
# # 使用模块变量
# print(calculate.number)
#
# # 使用模块中的类
# cal = calculate.Calculate(33)
# cal.test()
#
# calculate.Calculate.test1()  # 调用类Calculate中的类方法test1

from calculate import add, number

# from calculate import number

result = add(*list1)
print(result)

sum = result + number
print(sum)
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

1、os模块

# 模块:os.py(系统内置的模块)
'''
os.path
os.path.dirname(__file__)获取当前文件所在的文件目录（绝对路径）
os.path.join(path,'') 返回的是拼接后的新路径

'''
import os

# print(os.path)
# path = os.path.dirname(__file__)  # 获取当前文件所在文件目录。（绝对路径）
# print(path)
# print(type(path))           # 文件类型
# result = os.path.join(path,'aa.jpg')
# print(result)

with open(r'C:\Users\Lenovo\Desktop\p1\bb.jpg', 'rb') as stream:
    container = stream.read()  # 读取文件内容
    print(stream.name)
    file = stream.name
    filename = file[file.rfind('\\') + 1:]

    path = os.path.dirname(__file__)
    path1 = os.path.join(path, filename)

    with open(path1, 'wb') as wstream:
        wstream.write(container)

# 相对路径和绝对路径：
'''
os.path里的常用函数：

dirname()
join()
split()
splittext()
getsize()

isabs()   绝对路径
isfile()   文件
isdir()     文件夹
'''

import os

r = os.path.isabs(r'C:\Users\Lenovo\Desktop\p1\bb.jpg')
print('--->', r)

r = os.path.isabs('images/bb.jpg')  # ..\表示返回当前文件的上一级code找images
print('--->', r)

r = os.path.isabs(r'images\bb.jpg')  # 找跟os01.py同级的images里面的bb.jpg
print('--->', r)

# 获取路径：directory 目录  文件夹
# 当前文件所在文件路径
path = os.path.dirname(__file__)
print(path)

# 通过相对路径得到结对路径
path = os.path.abspath('code/aa/aa.txt')
print(path)

# 获取当前文件的绝对路径
path = os.path.abspath(__file__)
print(path)

# 得到当前文件所在文件夹所在路径
path = os.getcwd()  # getcwd() 得到当前文件所在文件夹所在
# 类似 os.path.dirname(__file__)
print(path)  # C:\Users\Lenovo\Desktop\day00函数\code\aa

r = os.path.isfile(os.getcwd())  # 判断当前文件是否是文件
print(r)

r = os.path.isdir(os.getcwd())  # 判断当前文件是否是文件夹
print(r)

# os.path
path = r'/os01.py'
result = os.path.split(path)  # 分割文件与文件名
print(result)
# ('C:\\Users\\Lenovo\\Desktop\\day00函数\\code\\aa', 'os01.py')
print(result[1])  # 拿到文件名
# 类似下：
# filename = path[path.rfind('\\')+1:]
# print(filename)

result = os.path.splitext(path)  # 分割文件与扩展名
print(result)
# ('C:\\Users\\Lenovo\\Desktop\\day00函数\\code\\aa\\os01', '.py')

result = os.path.getsize(path)      # 获取文件大小  单位字节
print(result)

result = os.path.join(os.getcwd(),'file','a','a1.jpg')  # join()在前面的路径上拼接后面的
print(result)
'''
os.path里面的:常用函数

dirname()
join()
split()
splitext()
getsize()

isabs()
isfile()
isdir()



'''
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

# os01中是os.path里的常用函数
# os中函数：
'''
os模块下常用的方法：
os.getcwd()  获取当前目录
os.listdir()    浏览文件夹
os.mkdir()  创建文件夹
os.remove() 删除空文件夹
os.chdir()  切换目录

'''
import os

# dir = os.getcwd()   # 获取当前文件的文件夹路径
# print(dir)
# # :\Users\Lenovo\Desktop\day00函数
#
# all = os.listdir(r'C:\Users\Lenovo\Desktop')
# print(all)

# 创建文件夹
# f = os.mkdir(r'C:\Users\Lenovo\Desktop\p3')
# print(f)

# 删除文件夹
# if not os.path.exists(r'C:\Users\Lenovo\Desktop\p3'):
#     f = os.mkdir(r'C:\Users\Lenovo\Desktop\p3')
#     print(f)
#
# f = os.rmdir(r'C:\Users\Lenovo\Desktop\p3')  # 只能删除空的文件夹 os
# print(f)
#
# f = os.removedirs(r'C:\Users\Lenovo\Desktop\p3')
# print(f)

# os.remove(r'C:\Users\Lenovo\Desktop\p3\p4\aa.txt')  # 删除文件

# 删除p4文件夹：
# path = r'C:\Users\Lenovo\Desktop\p3\p4'
#
# filelist = os.listdir(path)
# # print(filelist)
# for file in filelist:
#     path1 = os.path.join(path, file)    # 拼接
#     os.remove(path1)    # 删除p4里的文件及路径
# else:
#     os.rmdir(path)     # 删除p4文件夹
#
# print('删除成功！')

# 切换目录：
path = os.getcwd()
print(path)
f = os.chdir(r'C:\Users\Lenovo\Desktop\p1')
print(f)
path = os.getcwd()
print(path)
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

2. datetime模块

# datetime模块 : time的升级版
'''
datetime模块：
    time    时间
    date    日期      （date 数据）
    datetime    日期时间        now()
    timedelta   时间差     timedelta(dayd='',weeks='',hours=''.....)
'''
import datetime
import time

print(datetime.time.hour)
print(time.localtime().tm_hour)

# 因为date是类，所以要求创建对象
d = datetime.date(2020,9,23)
print(d.day)
print(time.time())
print(datetime.date.ctime(d))

# 时间差
timedel = datetime.timedelta(weeks=3,days=3,hours=10)
print(timedel)

# datetime.datetime.now() ---> 得到当前的日期和时间
now = datetime.datetime.now()
print(now)
result = now + timedel
print(result)

# 缓存：数据redis  作为缓存 redis.set(key,value,时间差） 会话：seesion
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. random模块

# random 模块
import random

ran = random.randrange(1,10,2)          # randrange(start,stop,step)    1~10 step=2--->1,3,5,7,9
print(ran)

ran = random.randrange(1,10)
print(ran)

ran = random.randint(1,10)
print(ran)

list1 = ['海龙','贾敏','金晨','纪翔']
ran = random.choice(list1)      # 随机选择列表里的值
print(ran)

pai = ['红桃A','黑桃K','方片8','梅花Q']
random.shuffle(pai)     # 打乱原列表顺序
print(pai)

# 验证码 大小写字母与数字的组合
def func():
    code = ''
    for i in range(4):
        ran1 = str(random.randint(0,9))
        ran2 = chr(random.randint(65,90))
        ran3 = chr(random.randint(97,122))

        r = random.choice([ran1,ran2,ran3])

        code += r

    return code

code = func()
print(code)
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

4. 循环导入

'''
循环导入：大型的Python项目中，需要很多python文件，由于架构不当，可能会出现模块之间的相互导入
    A:模块
     def test():
        f()
    B:模块
     def f()
        test()

避免产生循环导入：
    1.重新架构
    2.将导入的语句放到函数里面
    3.把导入语句放到模块的最后

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

文件操作

# 文件操作：
'''
    文件上传
    保存log

    系统函数：
    open(file,mode,buffering,encoding)

    读：
    open(path\filename,'rt') -----> 返回值是：stream(管道)
    container = stream.read()----> 读取管道中的内容

    注意：如果传递的path\filename有误，则会报错：FileNotFoundError
    如果是图片则不能使用默认得读取方式，mode = ‘rb’


    总结：
    read()      读取所有的内容
    readline()      每次读取一行
    readlines()     读取所有的内容保存到列表中
    readable()  判断是否可读的
'''
stream = open(r'C:\Users\Lenovo\Desktop\aa.txt')
# container = stream.read()
# print(container)


result = stream.readable()      # 判断是否是可读的 True  False
print(result)

# while True:
#     line = stream.readline()
#     print(line)
#     if not line:
#         break

lines = stream.readlines()      # 保存在列表里
print(lines)
for i in lines:
    print(i)


stream = open(r'C:\Users\Lenovo\Desktop\简历\bb.jpg','rb')     # 不能rt(文本)得rb（二进制）
container = stream.read()
print(container)
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

写文件
# '''
# stream = open(r'C:\Users\Lenovo\Desktop\aa.txt','w)
# mode 是’w‘ 表示就是写操作
#
# 方法：
#
#     write(内容)    每次都会清空，然后去写当前的内容
#     writelines(iterable)  没有换行的效果，如果需要换行，需要自己添加
#     mode 是 ’a' （append）则每次不会清空 ,而是在原有基础上追加
#
# '''

stream = open(r'C:\Users\Lenovo\Desktop\aa.txt', 'a')
# s = '''
# 你好！
#     欢迎来到澳门博彩赌场，赠送你一个金币！
#                     赌王：高进
#
# '''
# result = stream.write(s)
# print(result)
stream.write('龙五')
stream.write('张一山')
stream.writelines(['赌神高进\n','赌圣周星星\n','赌侠小刀\n'])

stream.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

# 文件的复制：
# '''
# 原文件：C:\Users\Lenovo\Desktop\p1\选课.png
# 目标文件：C:\Users\Lenovo\Desktop\p2


# with 结合open使用，可以帮助我们自动释放资源
# '''


with open(r'C:\Users\Lenovo\Desktop\p1\bb.jpg', 'rb') as stream:
    container = stream.read()  # 读取文件内容
    with open(r'C:\Users\Lenovo\Desktop\p2\bb.jpg','wb') as wstream:
        wstream.write(container)

print('文件复制完成！')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#  文件复制
import os

src_path = r'C:\Users\Lenovo\Desktop\p1'
target_path = r'C:\Users\Lenovo\Desktop\p2'

# 封装成函数
def copy(src, target):
    if os.path.isdir(src) and os.path.isdir(target):
        filelist = os.listdir(src)

        for file in filelist:

            path = os.path.join(src, file)
            with open(path, 'rb') as rstream:
                container = rstream.read()

                path1 = os.path.join(target, file)
                with open(path1, 'wb') as wstream:
                    wstream.write(container)
        else:
            print('复制完成！')


# 调用函数
#copy(src_path, target_path)
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

# 复制文件夹
import os

src_path = r'C:\Users\Lenovo\Desktop\p1'
target_path = r'C:\Users\Lenovo\Desktop\p3'


def copy(src_path, target_path):
    # 获取文件夹
    filelist = os.listdir(src_path)
    # 遍历列表
    for file in filelist:
        # 拼接路径
        path = os.path.join(src_path, file)
        # 判断是文件夹还是文件
        if os.path.isdir(path):
            # 递归调用copy
            copy(path, target_path)
        else:
        # 不是文件夹直接进行复制
            with open(path, 'rb') as rstream:
                container = rstream.read()

                path1 = os.path.join(target_path, file)
                with open(path1, 'wb') as wstream:
                    wstream.write(container)
    else:
        print('复制完成！')

# 调用copy
copy(src_path, target_path
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

异常处理（exception）

# 异常处理：
'''
格式：
try:
    可能出现的异常的代码
except：
    如果有异常执行的代码
finally：
    无论是否出现异常都会执行的代码

情况1：
try:
    有可能会产生多种异常
except 异常类型：
    print(.....)
except 异常类型：
    print(。。。。)
except Exception:
    pass

如果是多个except，异常类型最多的应该放在最下边

情况2：获取Exceptiond的错误原因
try:
    有可能会产生多种异常
except 异常类型：
    print(.....)
except 异常类型：
    print(。。。。)
except Exception as err:    # 获取错误原因
    print(err)  --》err的内容是错误原因


'''
try:
# 列表操作
    list = []
    list.pop()
# 文件操作
    with open(r'C:\Users\Lenovo\Desktop\p1\book\xx.txt','r') as rstream:
        print(rstream.read())

except Exception as err:
    print('出错了！',err)
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

示例

# 注册 用户名必须6位
def register():
    username = input('输入用户名：')
    if len(username)<6:
        raise Exception('用户名长度必须是6位以上！')
    else:
        print('输入用户名是：',username)

try:
    register()
except Exception as err:
    print(err)
    print('注册失败！')
else:
    print('注册成功！！')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

（列表）推导式

# 列表推导式 字典推导式 集合推导式
# 旧的列表  ---》新的列表
# 1.列表推导式： 格式：[表达式 for 变量 in 旧的列表] 或 [表达式 for 变量 in 旧的列表 if 条件]

# 过滤掉长度小于或者等于3的人名
names = ['tom', 'jack', 'lily', 'abc', 'steven', 'bob', 'ha']
result = [name for name in names if len(name) > 3]
print(result)

result = [name.capitalize() for name in names if len(name) > 3]
print(result)

'''
def func():
    newlist = []
    for name in names:
        if len(name)>3:
            name = name.title()
            newlist.append(name)
    return newlist
    
'''

# 0~5 偶数    0~10 奇数
# [(偶数,奇数),(偶数,奇数),(偶数,奇数)...]

newlist = [(x, y) for x in range(5) if x % 2 == 0 for y in range(10) if y % 2 != 0]
print(newlist)
'''
def func():
    newlist = []
    for i in range(5):      # 偶数
        if i % 2 == 0:
            for j in range(10):
                if j%2!= 0:     # 奇数
                    newlist.append((i, j))

    return newlist

x = func()
print(x)
'''
# list1 = [[1,2,3],[4,5,6],[7,8,9]] ----> [3,6,9]
list1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
newlist = [i[-1] for i in list1]
print(newlist)

# if 薪资大于5000加200，低于等于5000加500
dict1 = {'name': 'tom', 'salary': 5000}
dict2 = {'name': 'lucy', 'salary': 8000}
dict3 = {'name': 'jack', 'salary': 3000}
dict4 = {'name': 'lily', 'salary': 4500}

list1 = [dict1, dict2, dict3, dict4]

newlist = [employee['salary'] + 200 if employee['salary'] > 5000 else employee['salary'] + 500 for employee in list1]
print(newlist)

# 集合推导式
list1 = [1, 3, 4, 5, 6, 7, 1, 8, 0, 9, 8]
set1 = {x + 1 for x in list1 if x > 5}
print(set1)

# 字典推导式：(颠倒key和value的值)
dict1 = {'a': 'A', 'b': 'B', 'c': 'C', 'd': 'C'}
newdict1 = {value: key for key, value in dict1.items()}
print(newdict1)
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

迭代器（iteration）

'''
迭代是访问集合元素的一种方式
迭代器是可以记住遍历位置的一种对象
从集合的第一个元素访问，到最后一个元素结束。只能往前，不能往后。
迭代器的两个基本方法：iter() next()
迭代器使用：可以将可迭代对象转换成迭代器使用for循环进行遍历，或者while循环+next方法(字典里的函数items()将字典里的元素按照键值对的形式输出)
字符串、列表、元组都可以被用作创建迭代器对象
'''
# 可迭代的对象：1.生成器 2. 元组，列表。集合，字典，字符串
# 生成器本身也是迭代器对象
# 如何判断一个对象是否是可迭代的？
from collections import Iterable

list1 = [1,4,0,5,7,8]
f = isinstance(list1,Iterable)    # Iterable 可迭代的     instance 实例
print(f)

f = isinstance('abc',Iterable)
print(f)

f = isinstance(100,Iterable)
print(f)     # False

g = (x+1 for x in range(10))
f = isinstance(g,Iterable)
print(f)

'''
可以被next() 函数调用并不断返回下一个值得对象称为迭代器，Iterator

可迭代的 是不是肯定就是迭代器?
生成器是可迭代的，也是迭代器
list是可迭代的，但是,不是迭代器

list----》iter(list)-->迭代器
'''

# 列表转成迭代器：iter(转换对象)
list1 = [1,4,6,7,3]
list1 = iter(list1)   # 创建迭代器对象   通过函数iter() 将可迭代的变成了一个迭代器

print(next(list1))
print(next(list1))


# 迭代器
list = [1, 2, 3, 4]
it = iter(list)   # 创建迭代器对象
print(next(it))  # 输出迭代器的下一个对象  1
print(next(it))	 # 输出迭代器的下一个对象  2

# 使用for语句遍历迭代器对象
list02 = [5, 6, 7, 8]
it2 = iter(list02)
for i in it2:
	print(i, end = ", ")
'''
5, 6, 7, 8, 
'''

# 使用next()遍历迭代器对象
import sys

list03 = [9, 10, 11, 12, 13]
it3 = iter(list03)
while True:
	try:
		print(next(it3))
	except StopIteration:		# StopIteration用于标识迭代的完成，防止出现无限循环
		sys.exit()
'''
9
10
11
12
13
'''


# 创建一个迭代器
'''创建一个返回数字的迭代器，初始值为1，逐步递增1'''
class MyNumbers:
    def __iter__(self):     # 构造函数（方法）__iter__返回迭代器对象
        self.a = 1
        return self

    def __next__(self):     # 返回下一个迭代器对象
        x = self.a
        self.a += 1
        return x

myclass = MyNumbers()
myiter = iter(myclass)
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
'''
1
2
3
4
'''


# StopIteration使用
class MyNumbers02:
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        if self.a <= 10:
            x = self.a
            self.a += 1
            return x
        else:
            raise StopIteration


myclass02 = MyNumbers02()
myiter02 = iter(myclass02)

for x in myiter02:
    print(x, end=" ")
'''1 2 3 4 5 6 7 8 9 10''' 



'''
生成器与迭代器：
'''
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

生成器（generator）

"""
生成器本身也是迭代器对象
使用函数yield的函数叫做生成器
生成器与普通函数的不同之处是：其返回值是迭代器。即调用生成器函数返回迭代器的对象。
在调用生成器运行的过程中，每次遇到yield函数，生成器函数会暂停并保留当前所有的运行结果，返回yield值，并在执行next（）方法时候，从当前位置，继续运行。
"""
# 生成器是把列表的方括号改成小括号
newlist = [x * 3 for x in range(10)]
print(newlist)

# 得到生成器
g = (x * 3 for x in range(10))
print(type(g))  # <class 'generator'>
print(g)  # <generator object <genexpr> at 0x000001D04BC72BF8>

# # 方式一：
# print(g.__next__())
# print(g.__next__())
# print(g.__next__())
# print(g.__next__())
# print(g.__next__())
#
# # 方式二： next(生成器对象)  builtins 系统内置函数
# # 每调用一次next则会产生一个元素
# print(next(g))
# print(next(g))
# print(next(g))
# print(next(g))
# print(next(g))
# 方式三：
# while True:
#     try:
#         e = next(g)
#         print(e)
#     except:
#         print('没有更多的元素了！')

# 定义生成器的方式二：借助函数完成
# 只要函数中出现了yield关键字，说明函数不是函数了，编程生成器了
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

斐波那契数列

# 斐波拉契数列 Fibonacci series
# 两个元素之和确定下一个数
a, b = 0, 1
while b < 10:
  print(b)
  a, b = b, a + b
    
'''
1
1
2
3
5
8
'''

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

# 斐波那契数列 - 生成器函数
'''
定义生成器：

# 步骤：
# 1.定义一个函数，函数中使用yield关键字
# 2.调用函数，接受调用的结果
# 3.得到的结果就是生成器
# 4.借助于next(),__next__()得到元素
'''


# def func():
#     n = 0
#     while True:
#         n += 1
#         yield n  # return + 暂停
#
#
# g = func()  # g是一个迭代器，由生成器返回产生（借助产生一个生成器对象）
# # print(g)
#
# print(next(g))
# print(next(g))
# print(next(g))
# print(next(g))
# print(next(g))

# 斐波那契

def fib(length):
    a, b = 0, 1
    n = 0
    while n < length:
        yield b
        a, b = b, a + b
        n += 1
    return '没有更多元素了'  # return 就是你出现StopIteration的提示信息


g = fib(8)		# g是一个迭代器，由生成器返回产生
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
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

'''
生成器方法：
__next__(): 获取下一个元素
send(value):向每次生成器调用中传值 注意： 每一次需使用send(None)
'''


def gen():
    i = 0
    while i < 5:
        temp = yield i
        print('temp', temp)
        for x in range(temp):
            print('-------->', x)
        print('**************')

        i += 1
    return '没有更多的元素了'


g = gen()

print(g.send(None))
n1 = g.send(3)
print('n1',n1)
n2 = g.send(5)
print('n2',n2)
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

'''
生成器：generator

定义生成器的方式：
 1.通过列表推导式方式
    g = (x+1 for x in range(6))
 2.函数+yield
    def func():
        ...
        yield
        
    g = func()

 产生元素：
    1.next(generator) ----> 每次调用都会产生一个元素，如果元素产生完毕，再次调用就会报异常
    2.生成器自己的方法：
    g.__next__()
    g.send(value)
 应用：协程

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

装饰器（Decorators）

是修饰其他函数的功能的函数

理解python中的函数

一切皆对象

# 装饰器：装饰器是修饰其他函数功能的函数
# 理解python中的函数
def hi(name):
    return "hi " + name
print(hi("xiaoming"))  # hi xiaoming

def hi(name="xiaoming"):
    return "hi " + name
print(hi())  # hi xiaoming

# 也可以将一个函数赋给一个变量
greet = hi  # 这里没有使用小括号，是因为不是调用函数，只是将函数hi()放在变量greet里
print(greet())  # hi xiaoming

# 删除旧的函数，输出将存放函数的变量greet
del hi
print(hi())  # NameError: name 'hi' is not defined
print(greet())  # hi xiaoming
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在函数中定义函数

# 函数中定义函数
def hi(name="xiaolizi"):
    print("now you are inside the hi() function")

    def greet():
        return "now you are inside the greet() function"

    def wecome():
        return "now you are inside the wecome() function"

    print(greet())
    print(wecome())
    print("now you are back in the hi() function")


hi()
'''
now you are inside the hi() function
now you are inside the greet() function
now you are inside the wecome() function
now you are back in the hi() function
'''
# 无论何时调用hi()函数，greet()和wecome()函数都会被调用
# greet()和welcome()函数不能在hi()函数之外被访问
greet()         # NameError
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

从函数中返回函数

# 从函数中返回函数'''要点：if语句最后return的函数没有加小括号，就不会被执行，可以被赋值给其他的变量，到处传递。如果想'''def hi(name="Harry Potter"):    def greet():        return "now you are inside the greet() function"    def wecome():        return "now you are inside the wecome() function"    if name == "Harry Potter":        return greet  # 如果加上()函数就会被执行，不加小括号就可以被赋值给别的变量，而不去执行它。    else:        return wecome'''a = hi()print(a)  # <function hi.<locals>.greet at 0x7fae0007c8c8> 说明hi函数现在指向greet函数print(a())  # now you are inside the greet() function 执行了函数'''print(hi()())  # 也可以这样打印出:now you are inside the greet() function# 第一个括号实例化，第二个括号调用greet函数
1

第一个装饰器

原理：

# 第一个装饰器
def a_new_decorator(a_func):
    def wrapTheFuction():
        print("I doing some boring work before executing a_func()")
        a_func()	# 函数作为参数传递进来，这个带了小括号，执行这个函数
        print("I doing some boring work before executing a_func()")

    return wrapTheFuction


def a_func_requring_decoration():
    print("I am the function which needs some decoration to remove my foul smell")

'''
函数不加小括号（不加小括号就不会执行）可以作为一个参数到处传递
'''
a_func_requring_decoration()
"""
# output:
# I am the function which needs some decoration to remove my foul smell"""
a_func_requring_decoration = a_new_decorator(a_func_requring_decoration)
'''
将函数a_func_requring_decoration作为一个参数传递给函数a_new_decorator
进入函数，加载wrapTheFunction函数，
加载执行print("I doing some boring work before executing a_func()")
执行a_func_requring_decoration函数（带小括号）
加载执行print("I doing some boring work before executing a_func()")
'''
a_func_requring_decoration()
'''
# output:
# I doing some boring work before executing a_func()
# I am the function which needs some decoration to remove my foul smell
# I doing some boring work before executing a_func()
'''
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

装饰器：使用@符号

def a_new_decorator(a_func):
    def wrapTheFuction():
        print("I doing some boring work before executing a_func()")
        a_func()	# 函数作为参数传递进来，这个带了小括号，执行这个函数
        print("I doing some boring work before executing a_func()")

    return wrapTheFuction
  
@a_new_decorator
def a_func_requring_decoration():
    print("I am the function which needs some decoration to"
          " remove my foul smell")

a_func_requring_decoration()
'''
I doing some boring work before executing a_func()
I am the function which needs some decoration to remove my foul smell
I doing some boring work before executing a_func()
'''
print(a_func_requring_decoration.__name__)
# output:
# wrapTheFuction
# 输出wrapTheFunction是因为，a_func_requring_decoration被重写了。



# 解决这个问题，使用functools.wraps，阻止重写
from functools import wraps
def a_new_decorator(a_func):
  	@wraps(a_func)
    def wrapTheFuction():
        print("I doing some boring work before executing a_func()")
        a_func()	# 函数作为参数传递进来，这个带了小括号，执行这个函数
        print("I doing some boring work before executing a_func()")

    return wrapTheFuction
  
@a_new_decorator
def a_func_requring_decoration():
    print("I am the function which needs some decoration to"
          " remove my foul smell")

print(a_func_requring_decration.__name__)
'''
output:
a_func_requring_decoration
'''

注意⚠️：
'''
@wraps接受一个函数来进行装饰，并加入了复制函数名称、注释文档、参数列表等等的功能。这可以让我们在装饰器里面访问在装饰之前的函数的属性
'''
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

# 规范写法：
from functools import wraps

def decorator_name(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        if not can_run:
            return "Function not can run"
        return f(*args, **kwargs)
    return decorated

@decorator_name
def func():
    return "Function is running"

can_run = True
print(func())
"""
Function is running
"""
can_run = False
print(func())
"""
Function not can run
"""
     
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

使用场景

对return的理解

"""
测试：
    return 返回的值拿result02变量去接收。接受完通过print输出。
"""


def re():
    print("hello world01")
    return "hello world02"


re()  # hello world01

result02 = re() 
print(result02)  # re() 执行函数re，运行函数中的print。返回"hello world02"给result02，通过print将字符串输出

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

授权

日志

# 日志（Logging）
def login(func):
    @wraps(func)
    def with_logging(*args, **kwargs):
        print(func.__name__ + " was called")
        return func(*args, **kwargs)	# 如果将这行注释掉，会出现none

    return with_logging


@login
def addition_func(x):
    return x + x


result = addition_func(4)  # addition_func was called
print(result)  # 8
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在函数中嵌入装饰器（包裹函数）

'''
login函数中嵌入logging_decorator装饰器
a:打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。
也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
'''


def login(logfile='out.log'):
    def logging_decorator(func):
        @wraps(func)
        def wrapped_function(*args, **kwargs):
            log_string = func.__name__ + ' was called'
            print(log_string)
            # 打开logfile，并写入内容
            with open(log_string, 'a') as opened_file: # 没有log_string文件，创建
                # 打开创建好的文件，写入"你好"字符串
                opened_file.write("你好" + '\n')
            return func(*args, **kwargs)

        return wrapped_function

    return logging_decorator


@login()
def myfunc1():
    pass


myfunc1()  # myfunc1 was called


@login(logfile='func2.log')
def myfunc2():
    pass


myfunc2()  # myfunc2 was called
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

装饰器类

'''
需要将日志打印保留并发送至email。使用继承的场景。
'''
class login(object):
    def __init__(self, email = 'jiaohailong26@gmail.com', logfile='out.log'):  # 初始化方法（对象实例化时，执行）
        print("初始化方法被执行")
        self.email = email
        self.logfile = logfile

    def __call__(self, func):  # 对象调用方法（对象当成函数调用时，执行）
        print("对象调用方法被执行")
        @wraps(func)
        def wrapped_function(*args, **kwargs):
            log_string = func.__name__ + ' was called'
            print(log_string)
            # 打开logfile，并写入内容
            with open(log_string, 'a') as opened_file:  # 没有log_string文件，创建
                # 打开创建好的文件，写入"你好"字符串（"你好"即是日志内容）
                opened_file.write("你好" + '\n')
            # 发送一个通知（将日志内容发送email，实例化对象调用notify函数）
            self.notify()
            return func(*args, **kwargs)

        return wrapped_function

    def notify(self):
        print("已发送email。。。")


@login(logfile='func3.log')
def myfunc3():
    pass


myfunc3()
'''
初始化方法被执行
对象调用方法被执行
myfunc3 was called
已发送email。。。
'''
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

加密算法

# 加密算法：md5  sha1    sha256
# base64
import hashlib

msg = '于鹏中午一起去吃饭！'
md5 = hashlib.md5(msg.encode('utf_8'))  # md5不能识别字符串，编码成utf-8

print(md5.hexdigest())  # 转成16进制的表示方式：1d69eb1748766e2d03d333b0bf9cddf6

# 实例  登录加密
password = '123456'
list1 = []

sha256 = hashlib.sha256(password.encode('utf-8'))
list1.append(sha256.hexdigest())

pwd = input('请输入密码：')
sha256 = hashlib.sha256(pwd.encode('utf-8'))
pdw = sha256.hexdigest()
print(pwd)
print(list1)

for i in list1:
    if pdw == i:
        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
25

面向对象（类）

self代表类的实例，并非类。

_name 前单下划线 口头私有变量，虽然可以访问，但是请把我视为私有，不要随意访问

__name 前双下划线 私有变量，私有变量，私有化属性和方法，无法在外部直接访问

__ name __ 前后双下划线-特殊方法（魔术方法），

后置单下划线：为了避免与某些变量名冲突

'''
面向对象：
特点：封装性，继承性，多态性
程序          现实中
对象 ----》   具体的事物

现实中的事物---》转成电脑程序
世间万物皆对象

好处：

面向对象；
    类
    对象
    属性
    方法
  对象：
    纪翔的手机
    贾敏的手机
    菲菲的手机
    ...
    对象的集合  ---》 共同的特征：品牌    颜色  大小  价格  动作：打电话，发短信，刷视频
    类别： 手机类
           学生类
    于鹏，纪翔，嘉敏，菲菲

    特征：姓名 年龄 性别 身高 血型 婚否---》属性
    动作：刷抖音 敲代码 看书... ---> 方法

    多个对象--》提取对象的共同特征和动作---》封装到一个类
'''

class Phone:
    brand = 'phone'
    # 属性
    # brand = ''
    # 方法

jx = Phone()
print(jx.brand)

feifei = Phone()
print(feifei.brand)
feifei.brand = 'huawei'
print(feifei.brand)

xiaoming = Phone()
xiaoming.brand = 'xiaomi'
print(xiaoming.brand)
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

定义类和属性

# 定义类和属性
# 类名必须首字母大写，多个单词遵循驼峰式命名
# object是所有类的父亲，不写默认是object
class Student(object):
    # 类属性
    name = 'xiaowei'
    age = 2

xiaowei = Student()
# print(xiaowei.name)
# print(xiaowei.age)
xiaowei.age = 18
# print(xiaowei.age)
# xiaowei.name = 'yupeng'
# print(xiaowei.name)

Student.name = 'ajiao'
print(xiaowei.name)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

四种方法

1. 普通方法

# 类中方法：动作
# 种类：普通方法   类方法  静态方法   魔术方法

'''
# 类的方法和普通函数的区别：
	类的方法必须有额外的第一个参数，通常是self,self代表的是类的实例，类在调用的时候不需要额外的传入。
'''

'''
普通方法格式：
def 方法名（self,[参数，参数...]）:
    pass

'''


class Phone(object):
    brand = 'xiaomi'
    price = 4999
    type = '至尊星耀10'

    # Phone里面的方法：call
    def call(self):
        print('self--->:', self)
        print('正在访问通讯录：')
        for person in self.address_book:
            print(person.items())

        print('正在打电话----')
        print('留言是：', self.note)


Phone1 = Phone()
Phone1.note = '我是Phone1的note'
Phone1.address_book = [{'1538934791': '小伟'}, {'15800000000': '于鹏'}]
print(Phone1, '------1------')
Phone1.call()

Phone2 = Phone()
Phone2.note = '我是Phone1的note'
print(Phone2, '------2------')
Phone2.call()
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

# 函数  和  类里面定义的：方法

# def func(name):
#     print('---->', name)
#
#
# username = 'admin'
# func(username)


# def func(names):
#     for name in names:
#         print(name)
#
#
# name_list = ['aa', 'bb', 'cc']
# func(name_list)


class Phone:
    # 魔术方法一：__名字__() 称作魔术方法
    def __init__(self):
        print('*' * 30)
        self.brand = 'xiaomi'
        self.price = 5000

    def call(self):  # self是不断变化的
        print('---->call')
        print('价格：', self.price)  # price 阴影是因为，self是不断变化的，不能保证每个‘self’里面都有price


p = Phone()
p.call()
# p.price = 1000
# p.call()
#
# p1 = Phone()
# p1.call()
p1 = Phone()
p1.price = 1200

p1.call()
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

# 方式一：
class Person:
    name = '张三'

    def __init__(self):
        self.name = 'zhangsan'
        self.age = 18

    def eat(self):
        print('{}正在吃红烧肉！...'.format(self.name))

    def run(self):
        print('{},今年{}岁，正在跑步'.format(self.name, self.age))


p = Person()
p.name = '李四'
p.eat()
p.run()

p1 = Person()
p1.name = '王五'
p1.eat()
p.run()

p2 = Person()
p2.eat()
p2.run()

# 方式二：
class Person:
    name = '张三'

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

    def eat(self,food):
        print('{}正在吃{}！...'.format(self.name,food))

    def run(self):
        print('{},今年{}岁，正在跑步'.format(self.name, self.age))


p = Person('李四',18)
p.name = 'lisi'
p.eat('红烧肉')
p.run()

p1 = Person('王五',20)
p1.eat('洋芋叉叉')
p1.run()

p2 = Person('张飞',44)
p2.eat('蚂蚁上树')
p2.run()
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

2. 类方法

• 类方法概述

‘’’
特点：
1.定义需要依赖装饰器@classmethod
2.类方法中参数不是一个对象，而是类
3.类方法中只能使用类属性
4.类方法中能否使用普通方法？ 不能

类方法的作用：
因为只能访问类属性和类方法，所以可以在对象创建之前，如果需要完成一些动作（功能）
‘’’

• 示例

class Dog:
    def __init__(self, nickname):
        self.nickname = nickname

    def run(self):  # self 对象
        print('{}在院子里跑来跑去'.format(self.nickname))
    def eat(self):
        print('吃')
        self.run()  # 类方法的调用，需要通过self.方法名()

    @classmethod
    def test(cls):  # class
        print('----------')
        print(cls)  # <class '__main__.Dog'>
        # self.run()
        # print(cls.nickname)  报错
        # print(self.nickname)


Dog.test()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3. 静态方法

• 静态方法概述

‘’’
1.需要装饰器@staticmethod
2.静态方法是无需传递参数的（cls\self）
3.只能访问类的属性和方法，对象的是无法访问的
4.加载时机同类方法

总结：
类方法 静态方法
不同:
1.装饰器不同
2.类方法是有参数的，静态方法没有参数

相同：
1.只能访问类的属性和方法对象的不能访问
2.都可以通过类名调用访问
3.都可以在创建对象之前使用，因为是不依赖于对象的

普通方法 与 两者区别：
不同：
1.没有装饰器
2.普通方法永远依赖于对象，因为每个普通方法都有一个self
3.只有创建了对象才可以调用普通方法，否则无法调用

‘’’

• 示例

# 静态方法：
# 补充类方法：

class Person:
    __age = 18

    def show(self):
        print(Person.age)

    @classmethod
    def update_age(cls):
        cls.__age = 20
        print('----->类方法')


    @classmethod
    def show_age(cls):
        print('修改后的年龄是：',cls.__age)


    @staticmethod
    def text():
        print('------->静态方法')
        #print(self.name)  语法错误
        print(Person.__age)

Person.text()
Person.update_age()
Person.show_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

4. 魔术方法

• 魔术方法概述

- #### 魔术方法概述

'''魔术方法：

​	定义：魔术方法就是一个类\对象中的方法，和普通方法唯一不同的是，普通方法需要时，需要调用！而魔术方法是在特定时刻自动触发。


 __init__:初始化魔术方法(构造方法)

​	触发时机：初始化对象时触发（不是实例化触发，但是和实例在一个操作中）

 __new__:实例化的魔术方法

​	触发时机：在实例化时触发

 __call__:对象调用的魔术方法

​	触发时机：将对象当成函数使用的时候，会默认调用此函数的内容
 __del__:delete的缩写 析构魔术方法

​	触发时机：当对象没有用(没有任何变量引用)的时候被触发

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

• 示例

import sys


class Person:
    def __init__(self, name):
        print('------>init', self)  # ------>init <__main__.Person object at 0x000001E1A78A5B00>
        self.name = name

    def __new__(cls, *args, **kwargs):  # __new__ 向空间要地址 创建地址
        print('------>new')
        position = object.__new__(cls)
        print(position)  # <__main__.Person object at 0x000001E1A78A5B00>
        return position  # return 将地址 position 返给 self

    def __call__(self, name):
        print('------>call')
        print('执行对象得到的参数：', name)


p = Person('jack')
p1 = p
p2 = p

print(p1.name)
print(p2.name)

print(sys.getrefcount(p))  # 4   p p1 p2 调用一次

p('jack')

print(p)  # <__main__.Person object at 0x000001E1A78A5B00>
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

import sys
'''
__del__:
    1.对象赋值
     p = Person
     p1 = p
     说明：p 和 p1指向同一个地址
     
    2.删除地址的引用
     del p1 删除p1对地址的引用
     
    3.查看对地址的引用次数：
     import sys
     sys.getrefcount(p)
     
     4.当一块空间没有了任何引用，默认执行__del__
     
        ref = 0
'''


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

    def __del__(self):
        print('-------del------')


p = Person('jack')
p1 = p
p2 = p

print(p1.name)
print(p2.name)

p1.name = 'tom'
print(p.name)
print(p2.name)

del p2

print(sys.getrefcount(p))
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

# __str__
# 触发时机：打印对象名 自动触发去调用__str__里面的内容
# 注意：一定要在__str__方法中添加return,return后面的内容就是打印的内容了

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

    def __str__(self):
        return '姓名是：' + self.name + '年龄是：' + str(self.age)


p = Person('tom', 18)
print(p)

# 单纯的打印对象名称，出来的是一个地址。对于开发者来说没有太大意义
# 如果想打印对象名的时候能够给开发者更多一些信息量，

p1 = Person('jack',20)
print(p1)


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

class Student:
    # __age  = 18
    def __init__(self, name, age):
        self.name = name
        self.__age = age
        self.__score = 59

    # 先有getXXX
    @property
    def age(self):
        return self.__age

    # 再有set.因为set依赖get
    @age.setter
    def age(self, age):
        if age > 0 and age < 100:
            self.__age = age
        else:
            print('不在规定得范围内')


#     # 定义公有set和get方法
#     # set为了赋值
#     def setAge(self, age):
#         if age > 0 and age < 120:
#             self.__age = age
#         else:
#             print('赋值年龄不在规定范围内 ！！')
#
#     def setName(self, name):
#         self.__name = name
#
#     def setScore(self,score):
#         self.__score = score
#
#     # get为了取值
#     def getAge(self):
#         return self.__age
#
#     def getName(self):
#         return self.__name
#
#     def getscore(self):
#         return
#
#
#     def __str__(self):
#         return '姓名：{}，年龄：{}，考试分数：{}'.format(self.__name, self.__age, self.__score)
#
#     # attribute(属性):setName getName __str__ __init__
#
#
# s = Student('tom',20)
# print(dir(s))
# print(dir(Student))
s = Student('peng', 20)
print(s.name)

s.age = 130
print(s.age)
print(s.name)
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

# 声明（定义）Road 类
import random


class Road:
    def __init__(self, name, len):
        self.name = name
        self.len = len


# 声明（定义）Car 类
class Car:
    def __init__(self, brand, speed):
        self.brand = brand
        self.speed = speed

    def get_time(self, road):  # road = r road 与 r指向同一个地址空间
        ran_time = random.randint(1, 10)
        msg = '{}品牌的车，在{}上，以{}时速，行驶{}小时'.format(self.brand, road.name, self.speed, ran_time)

    def __str__(self):
        return '{}品牌的，速度：{}'.format(self.brand, self.speed)


# 创建实例化对象
r = Road('京藏高速', 120000)
print(r.name)
r.name = '京哈高速'

audi = Car('奥迪', 120)
print(audi)
audi.get_time(r)
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

5.四种方法总结

‘’’
魔术方法总结：
重点：

__init__ (构造方法，创建完空间之后调用的第一个方法)   __str__
 了解：
__new__ （实例化方法）作用：开辟空间

__del__ （析构方法）作用：没有指针引用的时候会调用。几乎不需要重写

__call__ （对象调用方法）作用：想不想将对象当作函数调用
1
2
3
4
5
6
7

大总结：
方法；
普通方法 —》重点
def 方法名(self,[参数])：
方法体

    对象.方法()
    
    方法之间的调用：
    class A:
        def a(self):
            pass
            
        def b(self): 
            # 调用a方法
            self.a()
1
2
3
4
5
6
7
8
9
10

​

类方法：
    @classmethod
    def 方法名(cls,[参数]):
        pass
        
    类名.方法名()
    对象.方法名()

静态方法：
    @staticmethod
    def 方法名([参数]):
        pass
        
    类名.方法名()
    对象.方法名()

魔术方法： 
     自动执行的方法
     需要在某种条件下触发
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

‘’’

两种关系（关联关系和继承关系）

关联关系

# 关联关系
# student   computer    book
# [has a\is a]
'''
1.has a
    一个类中使用了另外一种自定义的类型

    student使用computer  book
2.类型
    系统类型：
        str int  float
        list  dict  tuple  set
    自定义类型：
        算是自定义的类，都可以将其当作一种类型
        s= Student()
        s是Student类型的对象

'''


class Computer:
    def __init__(self, brand, color, type):
        self.brand = brand
        self.color = color
        self.type = type

    def online(self):
        print('正在使用电脑上网')

    def __str__(self):
        return self.brand + '----' + self.color + '-----' + self.type


class Book:
    def __init__(self, bname, author, number):
        self.bname = bname
        self.author = author
        self.number = number

    def __str__(self):
        return self.bname + '----' + self.author + '-----' + str(self.number)


class Student:
    def __init__(self, name, computer, book):  # book就是一个book对象
        self.name = name
        self.computer = computer
        self.books = []
        self.books.append(book)

    def borrow_book(self, book):
        for book1 in self.books:
            if book1.bname == book.bname:
                print('已经添加到你的列表里了')
                break
        else:
            self.books.append(book)

    def show_book(self):
        for book in self.books:
            print(book.bname)  # 通过book对象调他的bname属性，才能看到他的名字

    def __str__(self):
        return self.name + '---' + str(self.computer) + '---' + str(self.books)


# 创建对象
computer = Computer('mac', 'mac pro', '深灰色')

book = Book('盗墓笔记', '南派三叔', 10)

stu = Student('dahai', computer, book)
print(stu)

# 看借了哪些书
stu.show_book()

book1 = Book('鬼吹灯', '天下霸唱', 8)

stu.borrow_book(book1)

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

stu.show_book()
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

继承关系(继承)+(方法重写)

# 继承关系
# is a      
# 关于继承的术语：
# 	B类 继承 A类
# 		A类叫做：base class 父类 基类 超类(superclass)
# 		B类叫做：子类 派生类 subclass
'''
继承：
    Student,Employee,Doctor----->都是人类
    相同的代码---》代码冗余，可读性不高

    将相同的代码提取---》Person类
        Student,Employee,Doctor--->继承Person

        class Student(Person):
            pass

特点：
    1.如果类中不定义__init__,则需要调用父类(super class)中的__init__
    2.如果子类继承父类也需要定义自己的__init__，就需要在当前类(子类)的__init__上调用一下父类__init__
    3.如何调用父类__init__:（两种方式）
        super().__init__(参数)
        super(类名，对象).__init__(参数)
    4.如果父类有eat(),子类也定义一个eat方法，默认搜索的原则：先找当前类，再去找父类
    s.eat()
    override: 方法重写（方法覆盖）
    父类提供的方法不能子类的要求，就需要在子类中定义一个同名的方法，这中行为称为重写
    5.子类的方法中也可以调用父类的方法，在需要时
'''


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

    def eat(self):
        print(self.name + '正在吃饭。。。')

    def run(self):
        print(self.name + '正在跑步。。。')


class Student(Person):
    def __init__(self,name):
        print('-----student的init-----')
        # 如何调用父类的__init__
        super().__init__(name)    # super(). 父类对象


class Doctor(Person):
    pass


class Employee(Person):
    pass


# 创建对象
s = Student('jack')
s.run()

e = Employee('lily')
e.run()

d = Doctor('lucy')
d.run()
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

# 继承关系
# 如何定义子类里的__init__动作
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print(self.name + '正在吃饭。。。')

    def run(self):
        print(self.name + '正在跑步。。。')


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

    def study(self, course):
        print('{}正在学习{}课程。。。'.format(self.name, course))

    def eat(self, food):			# 方法重写
        super().eat()
        print(self.name + '---' + '正在吃饭。。。喜欢吃：' + food)


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


class Employee(Person):
    def __init__(self, name, age, salary, manager):
        super().__init__(name, age)
        self.salary = salary
        self.manager = manager


# 创建对象
s = Student('jack', 22, 'Python2020')
s.run()
s.study('python基础')
s.eat('满汉全席')

e = Employee('tom', 12, 10000, 'lucy')
e.run()

lists = ['a', 'b', 'c', 'd']
d = Doctor('lily', 40, lists)
d.run()
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

'''
编写一个简单的工资管理程序，系统可以管理一下四类人；工人（worker），销售员（salesman），经理（manager），销售经理（salemanager）,
所有的员工都具有员工号，姓名，工资等属性，有设置姓名，获取姓名，获取工号，计算工资的方法。
    1）工人：工人具有工作小时数和时薪的属性，工资计算方法为工作小时数*时薪
    2）销售员：具有销售额和提成比例的属性，工资计算方法为销售额*提成比例
    3)经理：具有固定月薪的属性，工资计算方法为固定月薪
    4）销售经理：工资计算方法为销售额*提成比例+固定月薪
请根据以上要求设计合理的类，完成一下功能：
    1）添加所有类型的人员
    2)计算月薪
    3）显示所有人工资情况
'''


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

    def __str__(self):
        msg = '工号：{}，姓名：{}，本月工资：奥奥{}'.format(self.no, self.name, self.salary)

    def getSalary(self):
        return self.salary


class Worker(Person):
    def __init__(self, name, no, salary, hours, per_hour):
        super(Worker, self).__init__(name, no, salary)
        self.hours = hours
        self.per_hour = per_hour

    def getSalary(self):
        money = self.hours * self.per_hour
        self.salary += money
        return self.salary


class Salaryman(Person):
    def __init__(self, name, no, salary, salemoney, percent):
        super(Salaryman, self).__init__(name, no, salary)
        self.salemoney = salemoney
        self.percent = percent

    def getSalary(self):
        money = self.salemoney * self.percent
        self.salary += money
        return self.salary


# 创建子类对象
w = Worker('king', '001', 2000, 160, 50)
s = w.getSalary()
print('月薪是：', s)

saler = Salaryman('lucy', '002', 5000, 50000000, 0.003)
s = saler.getSalary()
print(s)
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

# 多重继承与Mor-9
# class A:
#     def text1(self):
#         print('--------->AAAAAAAAAAA')
#
#
# class B:
#     def text2(self):
#         print('--------->BBBBBBBBBBB')
#
#
# class C(A, B):  # 多重继承
#     def text3(self):
#         print('--------->CCCCCCCCCC')
#
#
# c = C()
# c.text1()
# c.text2()
# c.text3()

class Base:
    print('-------Base------')


class A(Base):
    def text(self):
        print('--------->AAAAAAAAAAA')


class B(Base):
    def text(self):
        print('--------->BBBBBBBBBBB')


class C(Base):  # 多重继承
    def text(self):
        print('--------->CCCCCCCCCC')

class D(A,B,C):
   pass


d = D()
d.text()


# 多继承的搜索顺寻：经典类（从左至右，深度优先）  新式类（广度优先）
#Python2中是经典类
#Python3中是新式类
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

'''
封装（私有化）：

__age
def __show(self):
    pass

--> 类名 属性

私有化：封装  将属性私有化，定义公有的set和get方法
def setAge(self,age):
    判断
def getAge(self):
    return self.__age


s.setAge(20)
s.getAge()


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

    @property
    def age(self)：
        return ...

    @age.setter
    def age(self,age):
        self.__age = age


s = Student()
s.age = 10
print(s.age)


继承：
has a
class Student:
    def __init__(self,name,book):
        pass

is a
父类  子类
class Person:
     def run(self):
    ...

class Student(Person):
    ...

    def study(self):
        ...

    def run(self):
        super().run()
        ...


s = Student()
s.study()
s.run()

1.__init__
2.多重继承（广度优先的原则）
    D.__mro__--->查看搜索顺序、
    import inspect
    print(inspect.getmro(D))

'''



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

多态

# 多态    封装（私有化）    继承   ---》面向对象
# pet既可以接收cat,也可以接收dog,和tiger类型
class Person:
    def __init__(self, name):
        self.name = name

    def feed_pet(self, pet):  # pet既可以接收cat,也可以接收dog,和tiger类型
        # isinstance(obj,类)————> 判断obj是不是类的对象或者判断是不是该类子类的对象
        if isinstance(pet, Pet):
            print('{}喜欢养宠物：{},昵称是：{}'.format(self.name, pet.role, pet.nickname))
        else:
            print('不是宠物类型的。。。。')


class Pet:
    role = 'Pet'

    def __init__(self, nickname, age):
        self.nickname = nickname
        self.age = age

    def show(self):
        print('昵称：{}，年龄：{}'.format(self.nickname, self.age))


class Cat(Pet):
    role = '猫'

    def catch_mouse(self):
        print('抓老鼠。。。。')


class Dog(Pet):
    role = '狗'

    def watch_house(self):
        print('看家高手....')


class Tiger:
    def eat(self):
        print('太可怕了，可以吃人....')


# 创建对象
cat = Cat('花花', 2)

dog = Dog('大黄', 4)

tiger = Tiger()

person = Person('家伟')

person1 = Person('鹏鹏')
person1.feed_pet(cat)
person1.feed_pet(dog)


# pet 父类    cat dog 子类
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

对象实例

# 对象实例
# 猫
class Cat:
    type = '猫'

    # 通过__init__() 初始化的特征
    def __init__(self, nickname, age, color):
        self.nickname = nickname
        self.age = age
        self.color = color

    # 动作：方法
    def eat(self, food):
        print('{}喜欢吃{}'.format(self.nickname, food))

    def catch(self, color, weight):
        print('{},抓了{}kg的，{}老鼠'.format(self.nickname, weight, color))

    def sleep(self, hour):
        if hour < 5:
            print('乖乖！再睡会.....')
        else:
            print('赶快起床，出去抓老鼠.....')

    def show(self):
        print('猫的详细细信息：')
        print(self.nickname, self.age, self.color)


# 创建对象
cat1 = Cat('花花', 2, '灰色')

# 通过对象调用方法
cat1.catch('黑色', 10)

cat1.eat('小金鱼')

cat1.sleep(4)

cat1.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
28
29
30
31
32
33
34
35
36
37
38
39
40

私有化(封装)

# 私有化
# 封装： 1.私有化属性   2.定义公有的set和get方法
'''
好处：
1.隐藏属性不被外界随意修改
2.也可以修改：通过函数
    def setXXX(self,XXX):
        3.筛选赋值内容
        if XXX是否符合条件
            赋值
        else:
            不赋值
3.如果想获取具体的某一个属性
    使用get函数
        def getXXX(self):
            return self.__XXX


'''


class Student:
    # __age  = 18
    def __init__(self, name, age):
        self.__name = name
        self.__age = age
        self.__score = 59

    # 定义公有set和get方法
    # set为了赋值
    def setAge(self, age):
        if age > 0 and age < 120:
            self.__age = age
        else:
            print('赋值年龄不在规定范围内 ！！')

    def setName(self, name):
        self.__name = name

    def setScore(self,score):
        self.__score = score

    # get为了取值
    def getAge(self):
        return self.__age

    def getName(self):
        return self.__name

    def getscore(self):
        return

    def __str__(self):
        return '姓名：{}，年龄：{}，考试分数：{}'.format(self.__name, self.__age, self.__score)


# 创建对象
yupeng = Student('于鹏', 20)

print(yupeng.getAge())
print(yupeng.getName())
print(yupeng.getscore())

print(yupeng)
yupeng.setAge(100)
yupeng.setName('菲菲')
yupeng.setScore(95)
print(yupeng)
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

包

# 包的导入
# 文件夹   包
# 非py文件 包：py文件
# 项目 》 包  >  模块  》类 、  函数 、 变量

# 使用包中的User类
from user.models import User

u = User('admin', '123456')
u.show()

# 使用包中的Article类
from article.models import Article
a = Article('个人总结','家伟')
a.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

'''
__init__.py文件
当导入包的时候，默认调用__init__.py文件
作用：
1.当导入包的时候，把一些初始化的函数，变量，类 定义在__init__.py文件中
2.此文件中函数，变量的访问，只需要通过包名.函数...
3.结合__all__ = [通过*可以访问的模块]
'''
# import user  # ---->user的__init__
#
# from user.models import User
#
# user.creat_app()
# user.printA()

# from 模块 import *  如果没有定义__all__所有的都可以访问，表示可以使用模块了面的所有内容，
#                     但是如果添加上了__all__,只有__all__ = ['','']列表中的可以访问的

# from 包 import *     表示该包中的内容（模块）是不能访问的，就需要在__init__.py文件中定于__all__ = [可以通过*访问的模块]
from user import *

user = models.User('admin','123456')
user.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

第三方包

# 第三方：pillow        pip install pillow
# import pillow
import requests

response = requests.get('https://www.hao123.com/?1600515636')

print(response.text)
1
2
3
4
5
6
7

进程

进程的创建

# 进程的创建
'''
进程 》线程 》协程
from multiprocessing import Process

process = Process(target=函数，name=进程得名字，args=(给函数传递得参数))
process 对象

对象调用方法：
    process.start() 启动进程并执行任务
    process.run()  只是执行了任务但没有启动进程
    teminate() 终止
'''
# 进程 > 线程 > 协程

def task1(n):
    for i in range(n):
        print('正在搬第{}块砖'.format(i))
        yield None


def task2(n):
    for i in range(n):
        print('正在听第{}首歌'.format(i))
        yield None


g1 = task1(5)
g2 = task2(5)
try:
    while True:
        g1.__next__()
        g2.__next__()
except:
    pass








import os
from multiprocessing import Process
from time import sleep


def task1():
    while True:
        sleep(1)
        print('这是任务1。。。。。。', os.getpid(), '------', os.getppid())  # os.getpid()得到当前进程号  os.getppid() 得到父进程号


def task2():
    while True:
        sleep(1)
        print('这是任务2.。。。。', os.getpid(), '------', os.getppid())


number = 1
if __name__ == '__main__':  # 加这个的目的是：需要这个模块，在导入这个模块的时候不被执行下面的动作
    						# 当该文件被当作脚本执行时，执行这行代码下的文件，而被其他文件调用该文件的时候不执行下面的代码。
    # 子进程
    p = Process(target=task1, name='任务1')
    p.start()  # 启动进程
    print(p.name)

    p1 = Process(target=task2, name='任务2')
    p1.start()  # 启动进程
    print(p1.name)

    while True:
        number += 1
        sleep(0.1)
        if number == 100:
            p.terminate()
            p1.terminate()
            break
        else:
            print('---------->number:', number)

    print('-----', os.getpid(), '---父进程号--', os.getppid())
'''
执行结果：
# 父进程执行结果：

任务1                      
任务2                    
----- 14296 ----- 5776 
   
# 子进程执行结果：

这是任务1。。。。。。 14308 ------ 14296
这是任务2.。。。。 8220 ------ 14296
这是任务1。。。。。。 14308 ------ 14296
这是任务2.。。。。 8220 ------ 14296
'''
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

进程中传参

# 进程中传参
import os
from multiprocessing import Process
from time import sleep


def task1(s,name):
    while True:
        sleep(s)
        print('这是任务1。。。。。。', os.getpid(), '------', os.getppid(),name)


def task2(s,name):
    while True:
        sleep(s)
        print('这是任务2.。。。。', os.getpid(), '------', os.getppid(),name)


if __name__ == '__main__':
    # 子进程
    p = Process(target=task1, name='任务1',args=(1,'bb'))
    p.start()
    print(p.name)

    p1 = Process(target=task2, name='任务2',args=(2,'c'))
    p1.start()
    print(p1.name)

    print('-----', os.getpid(), '-----', os.getppid())
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

进程中全局变量的应用

# 进程中全局变量的应用：
'''
多进程对于全局变量访问，在每一个全局变量里面放一个m变量
保证每个进成访问互不干扰。
'''
import os
from multiprocessing import Process
from time import sleep

m = 1  # 不可变类型
list1 = []  # 不可变类型


def task1(s):
    global m
    while True:
        sleep(s)
        m += 1
        list1.append(str(m) + 'task1')
        print('这是任务1。。。。。。', m, list1)  # os.getpid()得到当前进程号  os.getppid() 得到父进程号


def task2(s):
    global m
    while True:
        sleep(s)
        m += 1
        list1.append(str(m)+'task2')
        print('这是任务2.。。。。', m,list1)


if __name__ == '__main__':
    # 子进程
    p = Process(target=task1, name='任务1', args=(1,))
    p.start()  # 启动进程

    p1 = Process(target=task2, name='任务2', args=(2,))
    p1.start()  # 启动进程

    while True:
        sleep(1)
        m += 1
        print('----->main', 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
34
35
36
37
38
39
40
41
42
43

自定义进程

# 进程：自定义
from multiprocessing import Process


class MyProcess(Process):

    def __init__(self, name):
        super().__init__()
        self.name = name

    # 重写run方法：
    def run(self):
        n = 1
        while True:
            print('{}----->进程名：{}'.format(self.name, n))
            n += 1


if __name__ == '__main__':
    p = MyProcess('小明')
    p.start()       # 1.开新的进程   2.run()

    p1 = MyProcess('小红')
    p1.start()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

进程池

# 进程池
'''
当需要创建的进程数不多时，可以利用 multiprocessing中的 Process 动态创建
但如果需要成百上千个目标，手动的创建进程工作量大，用 multiprocessing模块中提供的 pool方法

非阻塞式(asynchronous)：全部添加到队列中，立刻返回，并没有等待其他的进程完毕，但是回调函数是等待某一个任务完成之后才调用
阻塞式(synchronous)：
'''
import os
import time

# 非阻塞式进程
from multiprocessing import Pool
from random import random


def task(task_name):
    print('开始做任务了！！', task_name)
    start = time.time()
    # 使用sleep
    time.sleep(random() * 2)
    end = time.time()
    # print('完成任务:{}！   用时：{}   进程ID：{}'.format(task_name, (end - start), os.getpid()))
    return '完成任务:{}！   用时：{}   进程ID：{}'.format(task_name, (end - start), os.getpid())


container = []


def callback_func(n):
    container.append(n)


if __name__ == '__main__':
    pool = Pool(5)

    tasks = ['吃饭','听音乐','散步','洗衣服','洗碗','做饭','健身']
    for task1 in tasks:
        pool.apply_async(task, args=(task1,), callback=(callback_func))

    pool.close()  # 添加任务结束
    pool.join()  # pool依赖主进程存在，  join相当于插队，插到主进程前面

    for c in container:
        print(c)

    print('over!!!!!')
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

阻塞式进程池

# 进程池(阻塞式)
# 阻塞式
#   特点：添加一个执行一个任务，如果一个任务不结束另一个任务就进不来。
'''
进程池：
pool = Pool(max)  创建进程池对象
pool.apply()    阻塞式
pool.apply_async    非阻塞式

pool.close()
pool.join()     让主进程让步（插队）


'''
import os
import time
from multiprocessing import Pool
from random import random


def task(task_name):
    print('开始做任务了！！', task_name)
    start = time.time()
    # 使用sleep
    time.sleep(random() * 2)
    end = time.time()
    print('完成任务:{}！   用时：{}   进程ID：{}'.format(task_name, (end - start), os.getpid()))
    # return '完成任务:{}！   用时：{}   进程ID：{}'.format(task_name, (end - start), os.getpid())


if __name__ == '__main__':
    pool = Pool(5)
    tasks = ['吃饭', '听音乐', '散步', '洗衣服', '洗碗', '做饭', '健身']
    for task1 in tasks:
        pool.apply(task, args=(task1,))

    pool.close()
    pool.join()

    print('over!!!!!!')
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

进程间的通信

# 进程之间的通信
from multiprocessing import Queue

q = Queue(5)
q.put('A')
q.put('B')
q.put('C')
q.put('D')
q.put('E')
print(q.qsize())        # q.qsize()  获取队列的长度
if not q.full():        # q.full() 判断队列是否是满的     q.empty() 判断队列是否是空的
    q.put('F')
    q.put('G')
else:
    print('队列已满！！！！')


# 获取队列的值
print(q.get(timeout=2))
print(q.get(timeout=2))
print(q.get(timeout=2))
print(q.get(timeout=2))
print(q.get(timeout=2))
print(q.get(timeout=2))
print(q.get(timeout=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

# 进程之间的通信
from multiprocessing import Process
from multiprocessing import Queue
from time import sleep



def download(q):
    images = ['girl.jpg','boy.jpg','man.jpg']
    for image in images:
        print('正在下载：',image)
        sleep(0.5)
        q.put(image)


def getfile(q):
    while True:
        try:
            file = q.get(timeout=5)
            print('{}保存成功！'.format(file))
        except:
            print('全部保存完毕！！！！')
            break


if __name__ == '__main__':
    q = Queue(5)
    p1 = Process(target=download,args=(q,))
    p2 = Process(target=getfile,args=(q,))

    p1.start()
    p1.join()

    p2.start()
    p2.join()


    print('00000000000000000')
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

线程

# 线程：threadding
# 进程：Process
'''
线程的状态：
    新建  就绪  运行  阻塞  结束
'''
import threading
from time import sleep


def download(n):
    images = ['girl.jpg', 'boy.jpg', 'man.jpg']
    for image in images:
        print('正在下载：', image)
        sleep(n)
        print('下载图片：{} 完成！！！！'.format(image))


def lisenMusic():
    musics = ['大碗宽面','土耳其冰淇淋','烤馒头片','夏天的雨','华山','黄山','强军战歌','打靶归来']
    for music in musics:
        sleep(0.5)
        print('正在听{}歌'.format(music))


if __name__ == '__main__':
    # 线程对象
    t = threading.Thread(target=download, name='aa', args=(1,))
    t.start()

    t1 = threading.Thread(target=lisenMusic, name='bb')
    t1.start()

    # n = 1
    # while True:
    #     sleep(1.5)
    #     n += 1
    #     print(n)
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

# 线程
'''
线程是可以共享全局变量的
GIL 全局解释器锁
python3.6底层只要是线程默认加锁
'''
import threading
from time import sleep

ticket = 1000


def run1():
    global ticket
    for i in range(100):
        sleep(0.1)
        ticket -= 1


if __name__ == '__main__':
    th1 = threading.Thread(target=run1)
    th1.start()
    th2 = threading.Thread(target=run1)
    th2.start()
    th3 = threading.Thread(target=run1)
    th3.start()
    th4 = threading.Thread(target=run1)
    th4.start()

    th1.join()
    th2.join()
    th3.join()
    th4.join()

    print('剩余票：',ticket)
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

'''
数据共享：

lock = threading.Lock()

lock.acquire()  请求得到锁
....
lock.release()  释放锁

只要不释放其他线程都无法进入运行状态
'''
import threading
import time

lock = threading.Lock()

list1 = [0] * 10


def task1():
    # 获取线程锁，如果已经上锁，则等待锁的释放
    lock.acquire()  # 阻塞
    for i in range(len(list1)):
        list1[i] = 1
        time.sleep(0.5)
    lock.release()

def task2():
    lock.acquire()
    for i in range(len(list1)):
        print('---->',list1[i])
        time.sleep(0.5)
    lock.release()

if __name__ == '__main__':
    t1 = threading.Thread(target=task1)
    t2 = threading.Thread(target=task2)

    t1.start()
    t2.start()

    t1.join()
    t2.join()

    print('..............',list1)
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

生产者与消费者

'''
线程：
（生产者与消费者  线程中的简单应用 两个线程之间的通信

1.创建线程
A.    t = Thread(target=func,name='',args=(1,))  ---> 创建状态
      t.start()   ---> 就绪状态

      run()
      ioin()

B.自定义线程
    class MyThread(Thread):
        def __init__(self,name):
            super().__init__()
            self.name = name
        def run(self):
            任务

    t = MyThread('name')
    t.start()

3.数据共享
    进程共享数据与线程共享数据区别：
        进程是每个进程中都有一份
        线程是共同一个数据 ————》 数据安全性问题

    GIL (全局解释器锁) ---》 伪线程

    加锁：
    lock = Lock()
    lock.acquire()
    .......
    lock.release()

    ----> 只要用锁：死锁
    避免死锁  timeout=
 4.线程间通信：生产者与消费者
    生产者：线程
    消费者：线程
    import queue
    q = queue.Queue()
    # 创建生产者
    th = threading.Thread(target=produce,args=(q,))
    th.start()

    # 创建消费者
    tc = threading.Thread(target=consume,args=(q,))
    tc.start()

    q.put()
    q.get()







'''
import queue
import random
from threading import Thread
import time


def produce(q):
    i = 0
    while i < 10:
        num = random.randint(1, 100)
        q.put('生产者产生数据：%d' % num)
        print('生产者产生数据：%d' % num)
        time.sleep(1)
        i += 1
    q.put(None)
    # 完成任务
    q.task_done()


def consume(q):
    while True:
        item = q.get()
        if item is None:
            break
        print('消费者获到：%s' % item)
        time.sleep(4)
    # 完成任务
    q.task_done()


if __name__ == '__main__':
    q = queue.Queue(10)
    arr = []
    # 创建生产者
    th1 = Thread(target=produce, args=(q,))
    th1.start()
    # 创建消费者
    th2 = Thread(target=consume, args=(q,))
    th2.start()

    th1.join()
    th2.join()
    print('END')
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

死锁

# 死锁
'''
避免死锁：
 解决；1.重构代码
       2.timeout
'''
import time
from threading import Thread, Lock

lockA = Lock()
lockB = Lock()


class MyThread1(Thread):
    def run(self):
        if lockA.acquire():      # 如果可以获取到锁则返回True
            print(self.name + '获取了A锁')
            time.sleep(0.1)
            if lockB.acquire(timeout=5):
                print(self.name + '获取了B锁，原来还有A锁')
                lockB.release()
            lockA.release()

class MyThread2(Thread):
    def run(self):
        if lockB.acquire():      # 如果可以获取到锁则返回True
            print(self.name + '获取了B锁')
            time.sleep(0.1)
            if lockA.acquire(timeout=5):     # 阻塞
                print(self.name + '获取了A锁，原来还有B锁')
                lockA.release()
            lockB.release()


if __name__ == '__main__':
    t1 = MyThread1()
    t2 = MyThread2()

    t1.start()
    t2.start()
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

协程

# 协程
# 进程 》 线程  》协程
# Process Thread
import time


def task1():
    for i in range(3):
        print('A' + str(i))
        yield
        time.sleep(2)


def task2():
    for i in range(3):
        print('b' + str(i))
        yield
        time.sleep(1)

if __name__ == '__main__':
    g1 = task1()
    g2 = task2()

    while True:
        try:
            next(g1)
            next(g2)
        except:
            break
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

# 协程
# greenlet 完成协程任务
import time

from greenlet import greenlet


def a():
    for i in range(5):
        print('A' + str(i))
        gb.switch()
        time.sleep(0.1)


def b():
    for i in range(5):
        print('B' + str(i))
        gc.switch()
        time.sleep(0.1)


def c():
    for i in range(5):
        print('C' + str(i))
        ga.switch()
        time.sleep(0.1)


if __name__ == '__main__':
    ga = greenlet(a)
    gb = greenlet(b)
    gc = greenlet(c)

    ga.switch()
    gb.switch()
    gc.switch()
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

# 协程
# gevent 完成协程任务
import time

import gevent
from gevent import monkey

monkey.patch_all()


def a():
    for i in range(5):
        print('A' + str(i))
        time.sleep(0.1)


def b():
    for i in range(5):
        print('B' + str(i))
        time.sleep(0.1)


def c():
    for i in range(5):
        print('C' + str(i))
        time.sleep(0.1)


if __name__ == '__main__':
    g1 = gevent.spawn(a)
    g2 = gevent.spawn(b)
    g3 = gevent.spawn(c)

    gevent.joinall(g1,g2,g3)

    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
25
26
27
28
29
30
31
32
33
34
35
36

协程案例

# 协程案例
import urllib.request
import gevent
from gevent import monkey

monkey.patch_all()


def download(url):
    response = urllib.request.urlopen(url)
    content = response.read()
    print('下载了{}的数据，长度：{}'.format(url, len(content)))


if __name__ == '__main__':
    urls = ['http://www.163.com', 'http://www.qq.com', 'http://www.baidu.com']
    g1 = gevent.spawn(download, urls[0])
    g2 = gevent.spawn(download, urls[1])
    g3 = gevent.spawn(download, urls[2])

    #gevent.joinall(g1,g2,g3)
    g1.join()
    g2.join()
    g3.join()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

正则表达式

正则说明

1.正则表达式(Regular Express\简写 regex,regexp)的定义
    正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，
这个“规则字符串”用来表达对字符串的一种过滤逻辑。正则表达式是一种文本模式，模式描述在搜索文本时要匹配的一个或多个字符串。
2.正则表达式的作用和特点
给定一个正则表达式和另一个字符串，我们可以达到如下目的：
   1.给定的正则表达式是否符合正则表达式的过滤逻辑（称作”匹配“）
   2.可以通过正则表达式，从字符串中获取我们想要的特定部分。

正则的特点：
   1.灵活性，逻辑性和功能性非常强
1
2
3
4
5
6
7
8
9
10

使用正则re模块的match方法

import re

# 使用正则re模块方法：match
s = '娜扎佟丽娅热巴代斯'

result = re.match('佟丽娅', s)  # 只要从头进行匹配，如果匹配不成功就返回None
print(result)

result = re.search('佟丽娅', s)  # search 进行正则字符串匹配，匹配的是整个字符串
print(result)

print(result.span())  # 返回匹配的位置
print(result.group())  # 使用group提取到匹配的内容
print(result.groups())

# [] 表示一个范围
msg = 'abcd7dgs78sgv8d7d9gd9gd8g8dddd9999'
result = re.search('[a-z][0-9][a-z]', msg)  # search只要有匹配的后面就不会再检索了，找到一个就停止了
print(result)
print(result.group())

result = re.findall('[a-z][0-9][a-z]', msg)   # findall 匹配整个字符串，找到一个继续找，直到字符串结尾
print(result)

# a8w   e89d    i789d
msg = '1hjb4b5333jjk3kb434k5b3kk4bjk5bb3'
result = re.findall('[a-z][0-9]+[a-z]',msg)
print(result)

# qq号码验证 5~11 开头不能是0
qq = '123421'
result = re.match('^[1-9][0-9]{4,10}$',qq)
print(result)

# 不是4，7结尾的手机号码
phone = '15937483915'
result = re.match(r'1\d{9}[1-35-689]$',phone)
print(result)

# 爬虫
phone = '010-14764881'
result = re.match(r'(\d{3}|\d{4})-(\d{8})$',phone)
print(result)

# 分别提取
print(result.group())
# () 表示分组 group(1) 表示提取第一组的内容 group(2) 表示提取第二组的内容
print(result.group(1))
print(result.group(2))

#
msg = '<html>abc</html>'
msg1 = '<h1>hello</h1>'
result = re.match(r'<[0-9a-zA-Z]+>(.+)</[0-9a-zA-Z]+>',msg1)
print(result)
print(result.group(1))

# number
 # 1.
result = re.match(r'<([0-9a-zA-Z]+)>(.+)</\1>$',msg)  # \1 表示引用第一组的内容
print(result)
print(result.group(1))
print(result.group(2))

 # 2.
msg = '<html><h1>abc</h1></html>'
result = re.match(r'<([0-9a-zA-Z]+)><([0-9a-zA-Z]+)>(.+)</\2></\1>$',msg)
print(result)
print(result.group(1))
print(result.group(2))
print(result.group(3))

# 找类似a8d这种
msg = 'a7f3nb4kjb6bk3k3b6k36nb00'
result = re.findall('[a-z][0-9][a-z]', msg)
print(result)

# 用户名可以是字母或者数字，不能是数字开头，用户名长度必须6位以上[0-9a-zA-Z]
username = 'admin001'
result = re.search('^[a-zA-Z][0-9a-zA-Z]{5,}$', username)  # 如果想用search 加$表示从头匹配到尾
print(result)

msg = 'aa*py ab.txt bb.py kk.png uu.py apyb'
result = re.findall(r'py\b', msg)  # 加r就不会发生转义 或者用\\b
print(result)
result = re.findall(r'\w*\.py\b', msg)
print(result)

'''
正则预定义：
\s  空白 （空格）
\b 边界
\d 数字
\w word [0-9a-zA-Z_]

大写反面 \S 非空白  \D 非数字...

'\w[0-9]' ---> \w  [0-9] 只能匹配一个字母

'.'用于匹配除换行符（\n）之外的所有字符
'^'用于匹配字符串的开始，即行首
'$'用于匹配字符串的末尾（如果末尾有换行符、\n,就匹配\n前面的那个字符），即行尾
量词：
    *   >=0（贪婪模式）
    +   >=1（贪婪模式）
    ？   0,1（贪婪模式）

    手机号码正则：
    re.match('1[3589]\d{9}$',phone)
    
    {m} :固定m位
    {m,}:>=m
    {m,n}:phone>=m  phone<=n
    
'''
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

# 分组
# 匹配数字0-100
import re

n = '01'
result = re.match(r'[1-9]?\d?$|100$', n)
print(result)

# (word|word|word) 表示的是一个个的单词
# 区别  [163] 表示的是一个字母而不是一个单词
# 验证输入的邮箱 163   126  qq
email = '124532646@qq.com'
result = re.match(r'\w{5,20}@(163|qq|126)\.(com|cn)$',email)
print(result)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

import re

# 起名的方: (?P<名字>正则)  (?P=名字)
msg = '<html><h1>abc</h1></html>'
result = re.match(r'<(?P<name1>\w+)><(?P<name2>\w+)>(.+)</(?P=name2)></(?P=name1)>', msg)
print(result)  # java:小新,python:小新

# sub() 替换
result = re.sub(r'\d+', '小新', 'java:99,python:100')
print(result)


def func(temp):
    num = temp.group()
    num1 = int(num) + 1
    return str(num1)


result = re.sub(r'\d+', func, 'java:99,python:110')
print(result)  # java:100,python:111

# split()
result = re.split(r'[:,]', 'java:99,python:110')
print(result)

'''
07 讲的基础的内容
08/09 讲的分组的内容

分组：()  ---> result.group(1) 获取组中匹配的内容
        在分组的时候还可以结合 |
            n = '01'
            result = re.match(r'[1-9]?\d?$|100$', n)
            print(result)
不需要引用分组的内容：
    msg = '<html>abc</html>'
    msg1 = '<h1>hello</h1>'
    result = re.match(r'<[0-9a-zA-Z]+>(.+)</[0-9a-zA-Z]+>',msg1)
    print(result)
    
引用分组匹配的内容：
    1.number \number 引用第number组的数据
        result = re.match(r'<([0-9a-zA-Z]+)>(.+)</\1>$',msg)  # \1 表示引用第一组的内容
        print(result)
        print(result.group(1))
        print(result.group(2))
    2.?P<名字>
        msg = '<html><h1>abc</h1></html>'
        result = re.match(r'<(?P<name1>\w+)><(?P<name2>\w+)>(.+)</(?P=name2)></(?P=name1)>',msg)
        print(result)
        
re模块：
    match() 从开头匹配一次
    search()    只匹配一次
    findall()   查找所有
    sub('正则表达式','新内容',string) 替换
        result = re.sub(r'\d+','小新','java:99,python:100')
        print(result)
    
        def func(temp):
            num = temp.group()
            num1 = int(num) + 1
            return str(num1)
        
        result = re.sub(r'\d+',func,'java:99,python:110')
        print(result)  # java:100,python:111
    
    split() 
        result = re.split(r'[:,]','java:99,python:110')
        print(result)
        在字符串中搜索如果遇到：或者，就分割 将分割后的内容放到列表中
    

'''
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

爬取图片

# 爬取图片
import re

path = '<img class="j_large_pic" src="http://tiebapic.baidu.com/forum/pic/item/0fb30f2442a7d9336b3de12fba4bd11372f001d0.jpg" width="440" height="303.05">'
result = re.match(r'<img class="j_large_pic" src=(.+)"', path)
print(result)
print(result.group(1))
image_path = result.group(1)
import requests

response = requests.get(image_path)

with open('cc.jpg', 'wb') as wstream:
    wstream.write(response.content)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

条件控制语句

var1 = 100
if var1:
	print("1 - if 表达式条件为True")
	print(var1)
	
var2 = 0
if var2:
	print("2 - if 表达式条件为True")
	print(var2)
print("good bye!!")

'''
1 - if 表达式条件为True
100
good bye!!
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

循环语句

while循环

# 使用while循环实现输出1-50之间偶数 的

# 方式一：
sum = 0
i = 1
while i <= 50:

    if i % 2 == 0:
        sum += i
    i += 1
print('sum=', sum)

# 方式二：
sum = 0
for i in range(1, 51):
    if i % 2 == 0:
        sum += i

print('sum=', sum)
print('完成for循环之后i的值：', i)

# 方式一：

sum = 0
for i in range(10):
    if i % 3 != 0:
        sum += i
print('sum-----1111-->', sum)

# 方式二：

sum = 0

for i in range(10):
    # 任务一：
    if i % 3 == 0:
        #  pass    break    continue
        # break    跳出整个for循环语句
        pass
    # continue   跳过下方的语句不执行，继续执行下一次循环(在for循环中相当于跳过  sum+=i  继续执行for循环)
    #			跳出循环体中下方的语句不执行，直接进行下一次的循环
    # 任务二：
    sum += i

print('sum------2222-->', sum)

# 小案例
# 使用while循环实现输出1-50之间偶数 的

# 方式一：
sum = 0
i = 1
while i <= 50:

    if i % 2 == 0:
        sum += i
    i += 1
print('sum=', sum)

# 方式二：
sum = 0
for i in range(1, 51):
    if i % 2 == 0:
        sum += i

print('sum=', sum)
print('完成for循环之后i的值：', i)

# 方式一：

sum = 0
for i in range(10):
    if i % 3 != 0:
        sum += i
print('sum-----1111-->', sum)

# 方式二：

sum = 0

for i in range(10):
    # 任务一：
    if i % 3 == 0:
        #  pass    break    continue
        # break    跳出整个for循环语句
        pass
    # continue   跳过下方的语句不执行，继续执行下一次循环(在for循环中相当于跳过  sum+=i  继续执行for循环)
    #			跳出循环体中下方的语句不执行，直接进行下一次的循环
    # 任务二：
    sum += i

print('sum------2222-->', sum)


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

for循环

'''
for 变量名 in 集合：
	语句
'''
# 使用系统给定range()完成范围指定
# print(range(8))     #range(0,8) 包含0但不包含8    0，1，2，3，4，5，6，7，
# #打印三次
# for i in range(3):
# 	print('Hello!!!------->',i)


# #吃馒头


# #事例1
# name = '赵飞'
# for i in range(5):
# 	print('{}很饿，正在吃第{}个馒头'.format(name,i+1))
# print('{}说：终于吃饱了！'.format(name))


# #事例2
# name = '赵飞'
# for i in range(1,6):
# 	print('{}很饿，正在吃第{}个馒头'.format(name,i))
# print('{}说：终于吃饱了！'.format(name))


# #事例3  第三个馒头有毒
# name = '张无忌'
# for i in range(1,6):
# 	if i == 3:
# 		print("{}赶快扔掉这个馒头，有剧毒：'鹤顶红！！！'".format(name))
# 	else:
# 		print('{}很饿，正在吃第{}个馒头'.format(name,i))
# print('{}说：终于吃饱了！'.format(name))		


'''
for i in 范围：
	有数据执行的语句
else:
	没有数据执行的语句


pass 空语句
只要有缩进，而缩进的内容还不确定时，为了保证语法正确，使用pass占位

'''

# name = '赵飞'
# num = int(input('请输入需要的馒头数量：'))
# for i in range(num):
# 	print('{}很饿，正在吃第{}个馒头'.format(name,i+1))
# else:
# 	print('还没有给我馒头，{}都饿哭了.....'.format(name))

# print('-----------')


if 10 < 7:
    print('10是最大的')
else:
    pass  # pass 占位 保证语法可以正常进行
print('--------判断结束-------')

# break关键字
for i in range(3):
    username = input('请输入用户名：')
    password = input('请输入密码：')

    if username == 'songsong' and password == '123456':
        print('欢迎用户：{}'.format(username))
        print('---------轻松购物吧----------')
        break
    else:
        print('用户名或密码错误！')
else:
    print('账户被锁定，需要激活！')

for i in range(3):
    if i == 1:
        print('这家店是黑店，馒头有毒！等着关门吧！')
        print('------------>进入消协大门！')
        break  # 跳出循环结构
        print('dashj')  # 即使有语句，也不会执行
    else:
        print('馒头真香啊！要多吃几个！')
else:
    print('------>这家店太棒了！下次还来！')

'''

range的范围正常执行完毕，而没有异常break跳出。就可以执行else,
只要break执行了就不会执行else

'''

# 小案例
# python实现99乘法表

for i in range(1, 10):
    for j in range(1, i + 1):
        # print("%d * %d = %d" % (i, j, i * j), end=" ")
        print("{} * {} = {}".format(i, j, i * j), end=" ")
    # print("\n")
    print()



print("Hello World!",end="")
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

大总结

一、函数作用：

    将重复的代码，封装到函数，只要使用直接找函数。

    函数可以增强代码的模块化和提高代码的重复利用率。
定义函数：
    格式：
def 函数名([参数,参数,参数.....]):
    函数体(重复的代码)


注意：1.必须使用关键字def  2.函数体注意缩进   3.函数名() 绑定在一起的

二、集合
list tuple --->set()
无序不重复的序列，集合
无序---》跟下标相关

s = {1,23,456,6,5,43} ---->s[1]

for i in s:
    print(i)

内置函数：
添加：add  update
删除：remove  discard  pop  clear

运算相关的函数：
-   difference()    差集
|   union()     并集
&   intersection()  交集
^   symmetric_difference()  对称差集

可变和不可变：
可变：地址不变里面内容改变       list    dict    set
不可变：只要内容改变，必须改变你地址      int     str     float     tuple     frozenset

类型转换：
str--->list set ... 相互的转换
list--->set tuple dict 相互的转换

函数：
增加代码的复用性（减少了代码的冗余）

def 函数名(参数,参数...)
    函数体（重复代码）

三、回顾
函数：
函数的参数：普通参数  可变参数(*args(),**args{}),关键字参数
def func(a,b):
    pass

func(a=10,b=20)
返回值： return 值
def func():
    return 'abc',18

x = func()  ---> print(x) ---> ('abc',18)

def func():
    result = a+b
    print(result)

x = func()  ----> 没有返回值的话，接收到的值是None

函数间调用：
# 定义函数
def a():
    pass

def b():
    a()
    ....

# 调用：使用函数
b()
a()

局部和全局：
number = 100     不可变

list1 = [1,3,4,4,5]   可变

def func():
    global number
    name = 'abc'
    number += 1
    list1.append(8)

四、回顾
# 1.函数：
作用域:    LEGB

L:local  本地 局部变量

E:encloseing    嵌套

G:global    嵌套

B:built-in  内置的

# 2.嵌套函数

# 3.闭包：
     （1）内层函数
     （2）内层函数引用外层函数的变亮量
     （3）返回内层函数

# 4.装饰器：
     （1）内层函数
     （2）内层函数引用外层函数的变量
     （3）返回内层函数
     （4）函数作为外层函数的参数

# 5.使用装饰器

五、总结函数
普通函数：
def 函数名([参数...]):
    函数体

  1.如何定义函数
  2.调用函数

  参数：
  1.无参数：
  def func():
        pass
  func()
  2.有参数：
    一般参数：

    def func(a,b):
        pass


    func(1,2)
    
    可变参数：
    
    def func(*args,**kwargs):
        pass
    
    func()
    
    func(1)
    
    func(a=10)
    
    默认值参数：
    
    def func(a=10,b=10):
        pass
    
    func()
    
    func(20)
    
    关键字参数：
    func(b=99)
    
    返回值：return
    
    没有返回值
    
    def func():
        print('------')
    x = func()    ----> x=None
    
    有返回值：
    def func():
        return 'a'
    
    x = func()  -----> x = 'a'
    
    def func():
        return 'a','b
    
    x = func()  -----> x = ('a','b')

嵌套函数  ---》 闭包  ----》 装饰器

def func():
    def wraper():
        ...
    return wrapper

变量的作用域： LEGB
global      nonlocal
globals()  查看全局的变量  locals() 查看本函数的变量

装饰器：

单层装饰器：

def decorate(func):
    def wrapper(*args,**kwargs):
        ...

    return wrapper


@decorate
def house():
    pass

多层装饰器：
@zhuang1
@zhuang2
def f1(a,b):
    pass

装饰器带参数：
def outter(a):
    def decorate(func):
        def wrapper(*args,**kwargs):
        ...

        return wrapper
    return decorate

@zhuang(10)
def house():
    pass

匿名函数：lambda 参数：返回值

递归函数：自己调用自己

六、回顾
 匿名函数： lambda 参数，参数..:返回

 def func(参数，参数)：
    函数体

    return 值

 lambda x,y:x+y

 max()
 min()
 sorted()  ---->key=匿名函数

 map(func,list)  map是映射  在原来的list上做了func
 filter(func)  过滤 lambda x:x%2==0   返回值是：布尔类型的
 reduce()  --进行加减乘除-> from functools import reduce    (reduce不是builtins内置函数，要用导入)

递归函数：
    1.自己调用自己
    2.要有入口
    3.出口

文件操作：
open(path,mode)

mode ---> r         默认是r
s.read()
s.readline()
s.readlines()
s.readable()

with open('a1.txt') as fstreamm:
    pass

FileNotFoundError: [Errno 2] No such file or directory: 'a1.txt'

mode ---> w,a      w（清空原有的，再添加）append追加(在原有基础上添加)

with open('a1.txt','w') as wstreamm:    ---> 如果指定的文件不存在，则会自动创建一个
    wstreamm.write('hello')

write()
writelines()
writeable()

os模块：
os.path

七、文件
文件操作：
    open()
    path,filename:
        path:
            绝对路径：
            相对路径：相对当前文件的路径。返回上层目录：..\
    mode:
        读：rb    r
        写：wb    w
    stream = open(file,mode)
    stream.read()
    stream.write()
    stream.close()

    with open(file,mode) as stream:
        操作代码


    os模块：
    
    os.path:常用函数
        dirname()       获取指定文件的目录
        join()      拼接指定文件的目录
        split()     分割（文件目录，文件名）
        splittext()     分割（文件目录\文件名，文件扩展名）
        getsize()       获取文件大小
    
        isabs()   判断是否是绝对路径
        isfile()   判断是否是文件
        isdir()     判断是否是文件夹
    
    os常用函数：
        os模块下的方法：
            os.getcwd()  获取当前目录
            os.listdir()    浏览文件夹
            os.mkdir()  创建文件夹
            os.rm() 删除文件夹
            os.chdir()  切换目录

八、处理异常：

# 格式：
try:
    可能发生的异常代码
except:
    有异常才会进入的代码部分
[except 异常类型 as err:
    ...
]
[else:
    没有异常才会进入的代码
]
[finally:
    无论有没有异常都会执行的代码
]

# 抛出异常： 手动异常 raise
格式：
    raise 异常类型('提示信息')

九、回顾

列表推导式：
[表达式 for 变量 in 列表]

[x+2 for x in list1]---->新的列表

1.[表达式 for 变量 in 列表 if 条件]
[x+2 for x in list1 if x%2==0]

2.[结果A if 条件 else 结果B for x in 列表]
[x+2 if x%2==0 else x+1 for x in list1]

集合推导式：{表达式 for 变量 in 列表}  --》类似列表推导式，但是没有重复元素
字典推导式：{key,value for k,y in 字典.iterms()}

生成器：generator
1.使用类似的列表推导式 g = (表达式 for 变量 in 列表)
此时的g就是生成器
2.函数+yield

    def func():
        ....
        yield
        ....
    
    g = func()

   得到里面的元素：
        系统函数：next()
        生成器里面的函数：__next__(),send(None) ---- send(e)

可迭代的迭代器：
1.生成器 2.字符串，列表，集合...

Iterable

isinstance(x,Iterable) --->True False

生成器就是一个迭代器---> next(g)--->下一个元素
next(list)--->iter(list)--->next(iter(list))-->下一个元素

面向对象

类

cass 类名：
    特征：属性
    动作：方法

实例，对象

huawei = Phone()
huawei.price

十、回顾

类中的方法：
普通方法:
def func(self):--->self 对象
    pass

类方法
@classmothod
def func(cls):---->cls  类
    pass

静态方法
@staticmothod
def func():
    pass

魔术方法
__init__    __str__
__new__     __call__    __del__


p = Person()
p1 = p
p2 = p1

del p1
del p
ref = 0  ---》__del__   # ref 引用的意思

十一、回顾

面向对象的特点：
  # 封装，继承，多态
  1.封装：
    私有化属性，定义公有的set和get方法
    class Student:
        def __init__(self,age):
            self.__age = age

        @property           # 可以访问私有化的__age了
        def age(self):
            return self.__age
    
        @age.setter            # 可以修改私有化的__age了
        def age(self,age):
            self.__age = age


    s = Student()
    s.age = 10

  2.继承：
  is a:
  父类    子类
  class Student(Person):
    pass

  has a:

  class Student:
    def __init__(self,book,computer):
        book computer是自定义类型   ---系统类型


  s = Student()

  多继承：
  class C(A,B):
    pass

  C.__mro__

  3.多态：

  class Person:

    def food_pet(self,pet):
        isinstance(pet,Pet):
            pass






    继承示例：
    class Person:
        def __init__(self):
            self.__money = 200
            self.name = '匿名'
    
        def show1(self):
            print(self.name,self,__money)


    class Student(Person):
        def __init__(self):
            # super().__init__()
            # super(Student,self).__init__()
            # person.__init__(self)
            self.__money = 500
    
           def show(self):
               print('money',self.__money)
    
    s = Student()
    s.show()

十二、回顾

单例：__new__
class Singleton:
    __instance = None

    def __new__(cls):
        # 判断instance是否是None
        if cls.__instance is None:
            pass
        return cls.__instance
扩展：元类

模块：
    自定义的模块：
      xxx.py

      # 导入
      import xxx
    
      from xxx import xx
    
      from xxx import *   + __all__ = []
    
      __name__ --》自己：__main__ 别的使用：模块名

包：
    user
        --__init__.py   # 只要包的导入，都会默认执行__init__.py文件  __all__ = [] + from 包名 import *
        --xxx.py
        --xx.py
            --add
    article
        --aa.py

    bb.py
    
    from user.xx import add
    add()
    
    循环导入：避免
     1.重构代码
     2.将导入佛如语句放到函数中
     3.把导入的语句放到模块最后

系统模块：
    sys:sys.path    sys.version     sys.argv

    time 与 datetime
    
    random
第三方的模块：

十三、回顾(正则表达式)
re模块：
import re

re.match(pattern,string)
re.search(pattern,string)
re.findall(pattern,string)
re.sub(pattern,'新的内容',string)  替换
re.split(pattern,string)  --》[]

基础：
.任意字符
[]范围
|   或者
()  一组

量词：
*   >=0
+   >=1
?   0,1
{m}     =m
{m,}    >=m
{m,n}   >=m <=n

预定义：
\s  space
\S  not space
\d  digit
\D  not digit
\w  word [0-9a-zA-Z_]
\W  not word
\b  边界
\B  非边界

分组：
 ()  ---> group(1)

 number
    (\w+)(\d*)  ----> group(1) group(2)
    引用：
    (\w+)(\d*)  --> \1  \2

 name
    (?P<name>\w+)       (?P=name)

Python中的量词默认都是贪婪的(在少数语言里也可能是默认非贪婪)，总是尝试匹配尽可能多的字符；
非贪婪则相反，总是尝试匹配尽可能少的字符。

在”*“，”+”，“？”，“{m,n}”后面加上？，使贪婪变成非贪婪。

十四、 进程  线程
1)、进程
    1.创建进程：
    def func(n):  # n = 1
        pass
    p = Process(target=func,name='',args=(1,),kwargs='')
    p.start()

     自定义进程
    class MyProcess(Process):
    
        def run(self):
            pass
    
    p = MyProcess()
    p.start()
    
    2.进程数据共享：
    
    3.进程池：Pool
    p = Pool(5)
    4.阻塞式  apply(func,args,kargs)
    5.非阻塞式  apply_async(func,args,kargs,callback=函数)
    
    6.进程间通信
    
    Queue()
    q = Queue(4)
    
    q.put()
    q.get()
    q.qsize()
    q.empty()
    q.full()

2)、线程：
    包含关系

    进程里面可以存在着多个线程，多个线程公用进程资源
    
    t = Thread(target=func,name='',args=(1,),kargs='')
    t.start()
    
    GIL:全局解释器锁
    
    线程：‘伪线程’
    
    进程：
    
    线程同步：
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657

思维导图