Python3知识点学习与应用2020

学习的知识
- 1. 基础数学运算
- 2. if 判断形式
- 3. continue & break
- 4. for 循环
- 5. while 循环
- 6. try 错误处理
- 7. zip、 lambda、 map
- 8. range使用
- 9. 数据类型之--list、tuple、dict、set四种基本集合
- 10. 迭代器
- 11. 生成器
- 12. 函数参数
- 13. 模块安装
- 14. 导入模块
- 15. 自建模块并调用
- 16. 读写文件
- 17. class 类
- 18. input
- 19. copy & deepcopy 浅复制 & 深复制
- 20. 正则表达式
小技巧
学习资料链接:

**理清知识点，掌握新技能，实践创价值 **

学习的知识

1. 基础数学运算

加减乘除

>>> 1+1
2
>>> 2-1
1
>>> 2*3
6
>>> 4/3
1.3333333333333333

^ 与 **

#python当中^符号，区别于Matlab，在python中，^用两个**表示
>>> 3*2   # *2 表示乘以2
6
>>> 3**2  # **2 表示2次方
9
>>> 3**3  # **3 表示3次方
27

取余数 %

print(6%3)
>>> 0
print(5%3)
>>> 2
print(4%3)
>>> 1

取商 // 与 /

#只取商的整数部分
print(5//3)
>>> 1
print(4//3)
>>> 1
#取商的所有部分（按取值精度）
print(5/3)
>>> 1.6666666666666667
print(4/3)
>>> 1.3333333333333333

关系运算符

关系运算符	说明
>	大于，如果>前面的值大于后面的值，则返回 True，否则返回 False。
<	小于，如果<前面的值小于后面的值，则返回 True，否则返回 False。
==	等于，如果==两边的值相等，则返回 True，否则返回 False。
>=	大于等于（等价于数学中的 ≥），如果>=前面的值大于或者等于后面的值，则返回 True，否则返回 False。
<=	小于等于（等价于数学中的 ≤），如果<=前面的值小于或者等于后面的值，则返回 True，否则返回 False。
!=	不等于（等价于数学中的 ≠），如果!=两边的值不相等，则返回 True，否则返回 False。
is	判断两个变量所引用的对象是否相同，如果相同则返回 True，否则返回 False。
is not	判断两个变量所引用的对象是否不相同，如果不相同则返回 True，否则返回 False。

2. if 判断形式

if condition:expressions
#如果 condition 的值为 True,将会执行 expressions 语句的内容，否则将跳过该语句往下执行。

if condition:true_expressions
else:false_expressions
#当 if 判断条件为 True,执行 true_expressions 语句; 如果为 False，将执行 else 的内部的 false_expressions。

var = var1 if condition else var2
#如果 condition 的值为 True, 那么将 var1 的值赋给 var;如果为 False 则将 var2 的值赋给 var。

if condition1:true1_expressions
elif condition2:true2_expressions
elif condtion3:true3_expressions
elif ......
else:else_expressions
#如果有多个判断条件，那可以通过 elif 语句添加多个判断条件，一旦某个条件为 True，那么将执行对应的 expression。 并在之代码执行完毕后跳出该 if-elif-else 语句块，往下执行

3. continue & break

True and False ,当输入1时，a=False时，会执行接下来的语句后再跳出这个循环
break用法，在循环语句中，使用 break, 当符合跳出条件时，会直接结束循环。
在代码中，满足某一限定条件时，因为使用了 continue , python 不会执行 else 后面的代码，而会直接进入下一次循环。

#第一种跳出循环形式 ：True and False
a=True
while a:b= input('type somesthing：')if b=='1':a= Falseelse:passprint('still in while')
print ('finish run')
>>>
type somesthing:2
still in while
type somesthing:3
still in while
type somesthing:1
still in while    #会执行下面的语句再跳出
finish run#第二种跳出循环形式：break
while True:b= input('type somesthing:')if b=='1':breakelse:passprint('still in while')
print ('finish run')
>>>
type somesthing:4
still in while
type somesthing:5
still in while
type somesthing:1
finish run#第三种跳出循环形式：continue
while True:b=input('input somesthing:')if b=='1':continueelse:passprint('still in while' )print ('finish run')
>>>
input somesthing:3
still in while
input somesthing:1  # 没有"still in while"。直接进入下一次循环
input somesthing:4
still in while
input somesthing:...

4. for 循环

for item in sequence: #sequence 为可迭代的对象，item 为序列中的每个对象expressions

5. while 循环

while condition :expressions
#其中 condition 为判断条件，在 Python 中就是 True 和 False 其中的一个，如果为 True， 那么将执行 exexpressions 语句,否则将跳过该 while 语句块接着往下执行。

6. try 错误处理

try:file=open('eeee.txt','r')  #会报错的代码
except Exception as e:  # 将报错存储在 e 中print(e)
>>>
[Errno 2] No such file or directory: 'eeee.txt'
#处理错误：会使用到循环语句。首先报错：没有这样的文件No such file or directory. 然后决定是否输入y, 输入y以后，系统就会新建一个文件（要用写入的类型），再次运行后，文件中就会写入sssstry:file=open('eeee.txt','r+')
except Exception as e:print(e)response = input('do you want to create a new file:')if response=='y':file=open('eeee.txt','w')else:pass
else:file.write('ssss')file.close()
>>>
[Errno 2] No such file or directory: 'eeee.txt'
do you want to create a new file:yssss  #eeee.txt中会写入'ssss'

7. zip、 lambda、 map

#zip
#zip函数接受任意多个（包括0个和1个）序列作为参数，合并后返回一个tuple列表
a=[1,2,3]
b=[4,5,6]
ab=zip(a,b)
print(list(ab))  #需要加list来可视化这个功能
>>>
[(1, 4), (2, 5), (3, 6)]
#zip 中的运算a=[1,2,3]
b=[4,5,6]
ab=zip(a,b)
print(list(ab))
for i,j in zip(a,b):print(i/2,j*2)
>>>
[(1, 4), (2, 5), (3, 6)]
0.5 8
1.0 10
1.5 12#lambda
#lambda定义一个简单的函数，实现简化代码的功能，看代码会更好理解。fun= lambda x,y:x+y   #fun = lambda x,y : x+y, 冒号前的x,y为自变量，冒号后x+y为具体运算。
x=int(input('x='))    #这里要定义int整数，否则会默认为字符串
y=int(input('y='))
print(fun(x,y))
>>>
x=6
y=6
12#map
#map是把函数和参数绑定在一起。def fun(x,y):return (x+y)
>>> list(map(fun,[1],[2]))
[3]
>>> list(map(fun,[1,2],[3,4]))
[4,6]

8. range使用

共有三种使用方法：

range(start, stop)
其中 start 将会是序列的起始值，stop为结束值，但是不包括该值，类似数学中的表达 [start, stop),左边为闭区间，右边为开区间。
range(stop)
如果省略了 start 那么将从 0 开始，相当于 range(0, stop)
range(start, stop, step)
step 代表的为步长，即相隔的两个值得差值。从 start 开始，依次增加 step 的值，直至等于或者大于 stop。
使用range时需注意 i的取值（i 默认初始值从0 开始，最后一个值取不到）
示例1 ，当执行如下代码，并得到 i 值

for i in range(1,10):print(i)
>>>123456789

示例2 ，当执行如下代码时，得到 i 值

for i in range(10):print(i)
>>>0123456789

9. 数据类型之–list、tuple、dict、set四种基本集合

列表类型
而list是以中括号来命名的，他们的元素可以一个一个地被迭代、输出、运用、定位取值:

a_list = [12, 3, 67, 7, 82]lis = ['A', 1, 2]
for i in lis:print(i)#List 添加。列表是一系列有序的数列，有一系列自带的功能， 例如：
a = [1,2,3,4,1,1,-1]
a.append(0)  # 在a的最后面追加一个0
print(a)
>>> [1, 2, 3, 4, 1, 1, -1, 0]#在指定的地方添加项：
a = [1,2,3,4,1,1,-1]
a.insert(1,0) # 在位置1处添加0
print(a)
>>> [1, 0, 2, 3, 4, 1, 1, -1]#List 移除
#删除项：
a = [1,2,3,4,1,1,-1]
a.remove(2) # 删除列表中第一个出现的值为2的项
print(a)
>>> [1, 3, 4, 1, 1, -1]#List 索引
#显示特定位：
a = [1,2,3,4,1,1,-1]
print(a[0])  # 显示列表a的第0位的值
>>> 1
print(a[-1]) # 显示列表a的最末位的值
>>> -1
print(a[0:3]) # 显示列表a的从第0位 到 第2位(第3位之前) 的所有项的值
>>> [1, 2, 3]
print(a[5:])  # 显示列表a的第5位及以后的所有项的值
>>> [1, -1]
print(a[-3:]) # 显示列表a的倒数第3位及以后的所有项的值
>>> [1, 1, -1]#打印列表中的某个值的索引(index):
a = [1,2,3,4,1,1,-1]
print(a.index(2)) # 显示列表a中第一次出现的值为2的项的索引
>>> 1#统计列表中某值出现的次数：
a = [4,1,2,3,4,1,1,-1]
print(a.count(-1))
>>> 1#List 排序
#对列表的项排序：
a = [4,1,2,3,4,1,1,-1]
a.sort() # 默认从小到大排序
print(a)
>>> [-1, 1, 1, 1, 2, 3, 4, 4]
a.sort(reverse=True) # 从大到小排序
print(a)
>>> [4, 4, 3, 2, 1, 1, 1, -1]#多维列表
#创建二维列表
#一个一维的List是线性的List，多维List是一个平面的List：
a = [1,2,3,4,5] # 一行五列
multi_dim_a = [[1,2,3],[2,3,4],[3,4,5]] # 三行三列#索引
#在上面定义的List中进行搜索：
print(a[1])
>>> 2
print(multi_dim_a[0][1])
>>> 2

元组类型
叫做 tuple，用小括号、或者无括号来表述，是一连串有顺序的数字。他们的元素可以一个一个地被迭代、输出、运用、定位取值:

a_tuple = (12, 3, 5, 15 , 6)
another_tuple = 12, 3, 5, 15 , 6
tup = ('A', 1, 2)
for i in tup:print(i)

字典类型
如果说List是有顺序地输出输入的话，那么字典的存档形式则是无需顺序的。在字典中，有key和 value两种元素，每一个key对应一个value, key是名字, value是内容。数字和字符串都可以当做key或者value，在同一个字典中, 并不需要所有的key或value有相同的形式。这样说, List 可以说是一种key为有序数列的字典。正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key

dic = {}
dic['A'] = 'python'
dic['B'] = 1
dic['C'] = 2
for key in dic:print(key, dic[key])a_list = [1,2,3,4,5,6,7,8]
d1 = {'apple':1, 'pear':2, 'orange':3}
d2 = {1:'a', 2:'b', 3:'c'}
d3 = {1:'a', 'b':2, 'c':3}
print(d1['apple'])
>>> 1
print(a_list[0])
>>> 1
del d1['pear']
print(d1)
>>> {'orange': 3, 'apple': 1}
d1['b'] = 20
print(d1)
>>> {'orange': 3, 'b': 20, 'pear': 2, 'apple': 1}#字典存储类型
#以上的例子可以对列表中的元素进行增减。在打印出整个列表时，可以发现各个元素并没有按规律打印出来，进一步验证了字典是一个无序的容器。
def func():return 0
d4 = {'apple':[1,2,3], 'pear':{1:3, 3:'a'}, 'orange':func}
print(d4['pear'][3])
>>> a
#字典还可以以更多样的形式出现，例如字典的元素可以是一个List，或者再是一个列表，再或者是一个function。索引需要的项目时，只需要正确指定对应的key就可以了。

集合类型
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。要创建一个set，需要提供一个list作为输入集合。Set 最主要的功能就是寻找一个句子或者一个 list 当中不同的元素.

s = set(['A', 'B', 'C','D'])
for item in s:print(item)char_list = ['a', 'b', 'c', 'c', 'd', 'd', 'd']
sentence = 'Welcome Back to This Tutorial'
print(set(char_list))
>>> {'b', 'd', 'a', 'c'}print(set(sentence))
>>> {'l', 'm', 'a', 'c', 't', 'r', 's', ' ', 'o', 'W', 'T', 'B', 'i', 'e', 'u', 'h', 'k'}print(set(char_list+ list(sentence)))
>>> {'l', 'm', 'a', 'c', 't', 'r', 's', ' ', 'd', 'o', 'W', 'T', 'B', 'i', 'e', 'k', 'h', 'u', 'b'}#添加元素
#定义好一个 set 之后我们还可以对其添加需要的元素, 使用 add 就能添加某个元素. 但是不是每一个东西都能添加, 比如一个列表.unique_char = set(char_list)
unique_char.add('x')
# unique_char.add(['y', 'z']) this is wrong
print(unique_char)
>>> {'x', 'b', 'd', 'c', 'a'}#清除元素或 set
#清除一个元素可以用 remove 或者 discard, 而清除全部可以用 clear.unique_char.remove('x')
print(unique_char)
>>> {'b', 'd', 'c', 'a'}unique_char.discard('d')
print(unique_char)
>>> {'b', 'c', 'a'}unique_char.clear()
print(unique_char)
>>> set()#筛选操作
#我们还能进行一些筛选操作, 比如对比另一个东西, 看看原来的 set 里有没有和他不同的 (difference). 或者对比另一个东西, 看看 set 里有没有相同的 (intersection).unique_char = set(char_list)
print(unique_char.difference({'a', 'e', 'i'}))
>>> {'b', 'd', 'c'}print(unique_char.intersection({'a', 'e', 'i'}))
>>> {'a'}

10. 迭代器

可以直接作用于for循环的数据类型有以下几种：一类是集合数据类型，如list、tuple、dict、set、str等；一类是generator，包括生成器和带yield的generator function。这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。可以使用isinstance()判断一个对象是否是Iterable对象。生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。把list、dict、str等Iterable变成Iterator可以使用iter()函数。
小结：凡是可作用于for循环的对象都是Iterable类型；凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。Python的for循环本质上就是通过不断调用next()函数实现的

# define a Fib class
class Fib(object):def __init__(self, max):self.max = maxself.n, self.a, self.b = 0, 0, 1def __iter__(self):return selfdef __next__(self):if self.n < self.max:r = self.bself.a, self.b = self.b, self.a + self.bself.n = self.n + 1return rraise StopIteration()# using Fib object
for i in Fib(5):print(i)

11. 生成器

在Python中，这种一边循环一边计算的机制，称为生成器：generator。要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator。定义generator的另一种方法：如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator。这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。回到fib的例子，我们在循环过程中不断调用yield，就会不断中断。当然要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来。
小结：generator是非常强大的工具，在Python中，可以简单地把列表生成式改成generator，也可以通过函数实现复杂逻辑的generator。
要理解generator的工作原理，它是在for循环的过程中不断计算出下一个元素，并在适当的条件结束for循环。对于函数改成的generator来说，遇到return语句或者执行到函数体最后一行语句，就是结束generator的指令，for循环随之结束。请注意区分普通函数和generator函数，普通函数调用直接返回结果；generator函数的“调用”实际返回一个generator对象。

def fib(max):a, b = 0, 1while max:r = ba, b = b, a+bmax -= 1yield r# using generator
for i in fib(5):print(i)

12. 函数参数

函数声明只需要在需要默认参数的地方用 = 号给定即可, 但是要注意所有的默认参数都不能出现在非默认参数的前面

def function_name(para_1,...,para_n=defau_n,..., para_m=defau_m):expressions

如果执行该脚本的时候，该 if 判断语句将会是 True,那么内部的代码将会执行。如果外部调用该脚本，if 判断语句则为 False,内部代码将不会执行。

#自调用
if __name__ == '__main__':#code_here

定义了一个函数，传入一个参数为 name, 后面的参数 *grades 使用了 * 修饰，表明该参数是一个可变参数，这是一个可迭代的对象。该函数输入姓名和各科的成绩，输出姓名和总共成绩。

#可变参数
def report(name, *grades):total_grade = 0for grade in grades:total_grade += gradeprint(name, 'total grade is ', total_grade)

定义了一个函数，传入一个参数 name, 和关键字参数 kw，使用了 ** 修饰。表明该参数是关键字参数，通常来讲关键字参数是放在函数参数列表的最后。

#关键字参数
def portrait(name, **kw):print('name is', name)for k,v in kw.items():print(k, v)

小结：通过可变参数和关键字参数，任何函数都可以用 universal_func(*args, **kw) 表达。

13. 模块安装

这里的 Numpy 和 matplotlib 都是外部模块, 需要安装以后才会有的. 他不属于 python 自带的模块.

#导入外部模块
import numpy as np
import matplotlib.pyplot as plt

#安装模块
pip install packagename  #安装方法一
pip install -i http://pypi.douban.com/simple --trusted-host pypi.douban.com packagename #安装方法二

#更新外部模块
pip install -U packagename # 这是 python2+ 版本的用法
pip3 install -U packagename # 这是 python3+ 版本的用法

14. 导入模块

#import 的各种方法
#方法一：import time 指 导入 time 模块，这个模块可以python自带，也可以是自己安装的，比如以后会用到numpy这些模块,需要自己安装。import time
print(time.localtime())  #这样就可以print 当地时间了
>>>
time.struct_time(tm_year=2016, tm_mon=12, tm_mday=23, tm_hour=14, tm_min=12, tm_sec=48, tm_wday=4, tm_yday=358, tm_isdst=0)
#方法二：import time as __,__下划线缩写部分可以自己定义，在代码中把time 定义成 t.import time as t
print(t.localtime()) # 需要加t.前缀来引出功能
>>>
time.struct_time(tm_year=2016, tm_mon=12, tm_mday=23, tm_hour=14, tm_min=12, tm_sec=48, tm_wday=4, tm_yday=358, tm_isdst=0)#方法三：from time import time,localtime ,只import自己想要的功能.from time import time, localtime
print(localtime())
print(time())
>>>
time.struct_time(tm_year=2016, tm_mon=12, tm_mday=23, tm_hour=14, tm_min=41, tm_sec=38, tm_wday=4, tm_yday=358, tm_isdst=0)1482475298.709855#方法四：from time import * 输入模块的所有功能from time import *
print(localtime())
>>>
time.struct_time(tm_year=2016, tm_mon=12, tm_mday=23, tm_hour=14, tm_min=41, tm_sec=38, tm_wday=4, tm_yday=358, tm_isdst=0)

15. 自建模块并调用

#自建模块
#是计算五年复利本息的模块,代码如下：模块写好后保存在默认文件夹：balance.py
d=float(input('Please enter what is your initial balance: \n'))
p=float(input('Please input what is the interest rate (as a number): \n'))
d=float(d+d*(p/100))
year=1
while year<=5:d=float(d+d*p/100)print('Your new balance after year:',year,'is',d)year=year+1
print('your final year is',d)#调用自己的模块
#新开一个脚本，import balance
import balance
>>>
Please enter what is your initial balance:
50000  # 手动输入我的本金
Please input what is the interest rate (as a number):
2.3  #手动输入我的银行利息
Your new balance after year: 1 is 52326.45
Your new balance after year: 2 is 53529.95834999999
Your new balance after year: 3 is 54761.14739204999
Your new balance after year: 4 is 56020.653782067144
Your new balance after year: 5 is 57309.12881905469
your final year is 57309.12881905469

16. 读写文件

换行命令 \n

text='This is my first test. This is the second line. This the third '
print(text)  # 无换行命令
>>> This is my first test. This is the second line. This the thirdtext='This is my first test.\nThis is the second line.\nThis the third line'
print(text)   # 输入换行命令\n，要注意斜杆的方向。
>>>This is my first test.This is the second line.This the third line

\t tab 对齐

text='\tThis is my first test.\n\tThis is the second line.\n\tThis is the third line'
print(text)  #延伸 使用 \t 对齐
>>>This is my first test.This is the second line.This is the third line

open 读文件方式

text='This is my first test.\nThis is the second line.\nThis the third line'
my_file=open('my file.txt','w')   #用法: open('文件名','形式'), 其中形式有'w':write;'r':read.
my_file.write(text)               #该语句会写入先前定义好的 text
my_file.close()                   #关闭文件

给文件增加内容

append_text='\nThis is appended file.'  # 为这行文字提前空行 "\n"
my_file=open('my file.txt','a')   # 'a'=append 以增加内容的形式打开
my_file.write(append_text)
my_file.close()>>>This is my first test.This is the second line.This the third line.This is appended file.

读取文件内容，使用 file.read() 能够读取到文本的所有内容。

file= open('my file.txt','r')
content=file.read()
print(content)
>>>This is my first test.This is the second line.This the third line.This is appended file.

按行读取 file.readline(),如果想在文本中一行行的读取文本, 可以使用 file.readline(), 其读取的内容和你使用的次数有关, 使用第二次的时候, 读取到的是文本的第二行, 并可以以此类推:

file= open('my file.txt','r')
content=file.readline()  # 读取第一行
print(content)
>>>This is my first test.second_read_time=file.readline()  # 读取第二行
print(second_read_time)
>>> This is the second line.

读取所有行 file.readlines(),如果想要读取所有行, 并可以使用像 for 一样的迭代器迭代这些行结果, 我们可以使用 file.readlines(), 将每一行的结果存储在 list 中, 方便以后迭代.

file= open('my file.txt','r')
content=file.readlines() # python_list 形式
print(content)
>>> ['This is my first test.\n', 'This is the second line.\n', 'This the third line.\n', 'This is appended file.']#之后如果使用 for 来迭代输出:
for item in content:print(item)
>>>This is my first test.This is the second line.This the third line.This is appended file.

17. class 类

class 定义一个类, 后面的类别首字母推荐以大写的形式定义，比如Calculator. class可以先定义自己的属性，比如该属性的名称可以写为 name=‘Good Calculator’. class后面还可以跟def, 定义一个函数. 比如def add(self,x,y): 加法, 输出print(x+y). 其他的函数定义方法一样，注意这里的self 是默认值.

class Calculator:       #首字母要大写，冒号不能缺name='Good Calculator'  #该行为class的属性price=18def add(self,x,y):print(self.name)result = x + yprint(result)def minus(self,x,y):result=x-yprint(result)def times(self,x,y):print(x*y)def divide(self,x,y):print(x/y)
#注意定义自变量cal等于Calculator要加括号“()” ,cal=Calculator()否则运行下面函数的时候会出现错误,导致无法调用.

class 类 init 功能
__init__可以理解成初始化class的变量，取自英文中initial 最初的意思.可以在运行时，给初始值附值，运行c=Calculator(‘bad calculator’,18,17,16,15),然后调出每个初始值的值。__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去。

class Calculator:name='good calculator'price=18def __init__(self,name,price,height,width,weight):   # 注意，这里的下划线是双下划线self.name=nameself.price=priceself.h=heightself.wi=widthself.we=weight>>> c=Calculator('bad calculator',18,17,16,15)
>>> c.name
'bad calculator'
>>> c.price
18
>>> c.h
17
>>> c.wi
16
>>> c.we
15

如何设置属性的默认值, 直接在def里输入即可，如下:def init(self,name,price,height=10,width=14,weight=16):#查看运行结果，三个有默认值的属性，可以直接输出默认值，这些默认值可以在code中更改, 比如c.wi=17再输出c.wi就会把wi属性值更改为17.同理可推其他属性的更改方法。

class Calculator:name='good calculator'price=18def __init__(self,name,price,hight=10,width=14,weight=16): #后面三个属性设置默认值,查看运行self.name=nameself.price=priceself.h=hightself.wi=widthself.we=weight>>> c=Calculator('bad calculator',18)
>>> c.h
10
>>> c.wi
14
>>> c.we
16
>>> c.we=17
>>> c.we
17

18. input

variable=input() 表示运行后，可以在屏幕中输入一个数字，该数字会赋值给自变量。input()应用在if语句中。在下面代码中需要将input() 定义成整型，因为在if语句中自变量 a_input 对应的是1 and 2 整数型。输入的内容和判断句中对应的内容格式应该一致。也可以将if语句中的1 and 2 定义成字符串。

#注意这里要定义一个整数型
a_input=int(input('please input a number:'))
if a_input==1:print('This is a good one')
elif a_input==2:print('See you next time')
else:print('Good luck')
#注意这里要定义一个字符串类型
a_input=input('please input a number:')
if a_input=="1":print('This is a good one')
elif a_input=="2":print('See you next time')
else:print('Good luck')

#用input()来判断成绩
score=int(input('Please input your score: \n'))
if score>=90:print('Congradulation, you get an A')
elif score >=80:print('You get a B')
elif score >=70:print('You get a C')
elif score >=60:print('You get a D')
else:print('Sorry, You are failed ')
>>>
Please input your score:
100   #手动输入
Congradulation, you get an A

19. copy & deepcopy 浅复制 & 深复制

浅拷贝
#当使用浅拷贝时，python只是拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。

>>> import copy
>>> a=[1,2,3]
>>> c=copy.copy(a)  #拷贝了a的外围对象本身,
>>> id(c)
4383658568
>>> print(id(a)==id(c))  #id 改变 为false
False
>>> c[1]=22222   #此时，我去改变c的第二个值时，a不会被改变。
>>> print(a,c)
[1, 2, 3] [1, 22222, 3] #a值不变,c的第二个值变了，这就是copy和‘==’的不同

深拷贝
deepcopy对外围和内部元素都进行了拷贝对象本身，而不是对象的引用。

#copy.copy()
>>> a=[1,2,[3,4]]  #第三个值为列表[3,4],即内部元素
>>> d=copy.copy(a) #浅拷贝a中的[3，4]内部元素的引用，非内部元素对象的本身
>>> id(a)==id(d)
False
>>> id(a[2])==id(d[2])
True
>>> a[2][0]=3333  #改变a中内部原属列表中的第一个值
>>> d             #这时d中的列表元素也会被改变
[1, 2, [3333, 4]]#copy.deepcopy()
>>> e=copy.deepcopy(a) #e为深拷贝了a
>>> a[2][0]=333 #改变a中内部元素列表第一个的值
>>> e
[1, 2, [3333, 4]] #因为时深拷贝，这时e中内部元素[]列表的值不会因为a中的值改变而改变

20. 正则表达式

正则表达式 (Regular Expression) 又称 RegEx, 是用来匹配字符的一种工具. 在一大串字符中寻找你需要的内容. 它常被用在很多方面, 比如网页爬虫, 文稿整理, 数据筛选等等. 最简单的一个例子, 比如我需要爬取网页中每一页的标题. 而网页中的标题常常是这种形式。

<title>我是标题</ title>

而且每个网页的标题各不相同, 我就能使用正则表达式, 用一种简单的匹配方法, 一次性选取出成千上万网页的标题信息. 正则表达式绝对不是一天就能学会和记住的, 因为表达式里面的内容非常多, 强烈建议, 现在这个阶段, 你只需要了解正则里都有些什么, 不用记住, 等到你真正需要用到它的时候, 再反过头来, 好好琢磨琢磨, 那个时候才是你需要训练自己记住这些表达式的时候.

分组
我们甚至可以为找到的内容分组, 使用 () 能轻松实现这件事. 通过分组, 我们能轻松定位所找到的内容. 比如在这个 (\d+) 组里, 需要找到的是一些数字, 在 (.+) 这个组里, 我们会找到 “Date: “ 后面的所有内容. 当使用 match.group() 时, 他会返回所有组里的内容, 而如果给 .group(2) 里加一个数, 它就能定位你需要返回哪个组里的信息.

match = re.search(r"(\d+), Date: (.+)", "ID: 021523, Date: Feb/12/2017")
print(match.group())                   # 021523, Date: Feb/12/2017
print(match.group(1))                  # 021523
print(match.group(2))                  # Date: Feb/12/2017#有时候, 组会很多, 光用数字可能比较难找到自己想要的组, 这时候, 如果有一个名字当做索引, 会是一件很容易的事. 我们字需要在括号的开头写上这样的形式 ?P<名字> 就给这个组定义了一个名字. 然后就能用这个名字找到这个组的内容.match = re.search(r"(?P<id>\d+), Date: (?P<date>.+)", "ID: 021523, Date: Feb/12/2017")
print(match.group('id'))                # 021523
print(match.group('date'))              # Date: Feb/12/2017

重复匹配
如果我们想让某个规律被重复使用, 在正则里面也是可以实现的, 而且实现的方式还有很多

#具体可以分为这三种:* : 重复零次或多次+ : 重复一次或多次{n, m} : 重复 n 至 m 次{n} : 重复 n 次#举例如下:# * : occur 0 or more times
print(re.search(r"ab*", "a"))             # <_sre.SRE_Match object; span=(0, 1), match='a'>
print(re.search(r"ab*", "abbbbb"))        # <_sre.SRE_Match object; span=(0, 6), match='abbbbb'># + : occur 1 or more times
print(re.search(r"ab+", "a"))             # None
print(re.search(r"ab+", "abbbbb"))        # <_sre.SRE_Match object; span=(0, 6), match='abbbbb'># {n, m} : occur n to m times
print(re.search(r"ab{2,10}", "a"))        # None
print(re.search(r"ab{2,10}", "abbbbb"))   # <_sre.SRE_Match object; span=(0, 6), match='abbbbb'>

按类型匹配
除了自己定义规则, 还有很多匹配的规则时提前就给你定义好了的. 下面有一些特殊的匹配类型给大家先总结一下, 然后再上一些例子.

    \d : 任何数字\D : 不是数字\s : 任何 white space, 如 [\t\n\r\f\v]\S : 不是 white space\w : 任何大小写字母, 数字和 “” [a-zA-Z0-9]\W : 不是 \w\b : 空白字符 (只在某个字的开头或结尾)\B : 空白字符 (不在某个字的开头或结尾)\\ : 匹配 \. : 匹配任何字符 (除了 \n)^ : 匹配开头$ : 匹配结尾? : 前面的字符可有可无#下面就是具体的举例说明# \d : decimal digit
print(re.search(r"r\dn", "run r4n"))           # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \D : any non-decimal digit
print(re.search(r"r\Dn", "run r4n"))           # <_sre.SRE_Match object; span=(0, 3), match='run'>
# \s : any white space [\t\n\r\f\v]
print(re.search(r"r\sn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(0, 3), match='r\nn'>
# \S : opposite to \s, any non-white space
print(re.search(r"r\Sn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \w : [a-zA-Z0-9_]
print(re.search(r"r\wn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \W : opposite to \w
print(re.search(r"r\Wn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(0, 3), match='r\nn'>
# \b : empty string (only at the start or end of the word)
print(re.search(r"\bruns\b", "dog runs to cat"))    # <_sre.SRE_Match object; span=(4, 8), match='runs'>
# \B : empty string (but not at the start or end of a word)
print(re.search(r"\B runs \B", "dog   runs  to cat"))  # <_sre.SRE_Match object; span=(8, 14), match=' runs '>
# \\ : match \
print(re.search(r"runs\\", "runs\ to me"))     # <_sre.SRE_Match object; span=(0, 5), match='runs\\'>
# . : match anything (except \n)
print(re.search(r"r.n", "r[ns to me"))         # <_sre.SRE_Match object; span=(0, 3), match='r[n'>
# ^ : match line beginning
print(re.search(r"^dog", "dog runs to cat"))   # <_sre.SRE_Match object; span=(0, 3), match='dog'>
# $ : match line ending
print(re.search(r"cat$", "dog runs to cat"))   # <_sre.SRE_Match object; span=(12, 15), match='cat'>
# ? : may or may not occur
print(re.search(r"Mon(day)?", "Monday"))       # <_sre.SRE_Match object; span=(0, 6), match='Monday'>
print(re.search(r"Mon(day)?", "Mon"))          # <_sre.SRE_Match object; span=(0, 3), match='Mon'>#如果一个字符串有很多行, 我们想使用 ^ 形式来匹配行开头的字符, 如果用通常的形式是不成功的.
# 比如下面的 “I” 出现在第二行开头, 但是使用 r"^I" 却匹配不到第二行, 这时候, 我们要使用 另外一个参数, 让 re.search() 可以对每一行单独处理. 这个参数就是 flags=re.M, 或者这样写也行 flags=re.MULTILINE.string = """
dog runs to cat.
I run to dog.
"""
print(re.search(r"^I", string))                 # None
print(re.search(r"^I", string, flags=re.M))     # <_sre.SRE_Match object; span=(18, 19), match='I'>

灵活匹配
除了上面的简单匹配, 下面的内容才是正则的核心内容, 使用特殊的 pattern 来灵活匹配需要找的文字.如果需要找到潜在的多个可能性文字, 我们可以使用 [] 将可能的字符囊括进来. 比如 [ab] 就说明我想要找的字符可以是 a 也可以是 b. 这里我们还需要注意的是, 建立一个正则的规则, 我们在 pattern 的 “” 前面需要加上一个 r 用来表示这是正则表达式, 而不是普通字符串. 通过下面这种形式, 如果字符串中出现 “run” 或者是 “ran”, 它都能找到.

# multiple patterns ("run" or "ran")
ptn = r"r[au]n"       # start with "r" means raw string
print(re.search(ptn, "dog runs to cat"))    # <_sre.SRE_Match object; span=(4, 7), match='run'>#同样, 中括号 [] 中还可以是以下这些或者是这些的组合. 比如 [A-Z] 表示的就是所有大写的英文字母. [0-9a-z] 表示可以是数字也可以是任何小写字母.print(re.search(r"r[A-Z]n", "dog runs to cat"))     # None
print(re.search(r"r[a-z]n", "dog runs to cat"))     # <_sre.SRE_Match object; span=(4, 7), match='run'>
print(re.search(r"r[0-9]n", "dog r2ns to cat"))     # <_sre.SRE_Match object; span=(4, 7), match='r2n'>
print(re.search(r"r[0-9a-z]n", "dog runs to cat"))  # <_sre.SRE_Match object; span=(4, 7), match='run'>

简单的匹配
正则表达式无非就是在做这么一回事. 在文字中找到特定的内容, 比如下面的内容. 我们在 “dog runs to cat” 这句话中寻找是否存在 “cat” 或者 “bird”.

# matching string
pattern1 = "cat"
pattern2 = "bird"
string = "dog runs to cat"
print(pattern1 in string)    # True
print(pattern2 in string)    # False#但是正则表达式绝非不止这样简单的匹配, 它还能做更加高级的内容. 要使用正则表达式, 首先需要调用一个 python 的内置模块 re. 然后我们重复上面的步骤, 不过这次使用正则. 可以看出, 如果 re.search() 找到了结果, 它会返回一个 match 的 object. 如果没有匹配到, 它会返回 None. 这个 re.search() 只是 re 中的一个功能, 之后会介绍其它的功能.import re# regular expression
pattern1 = "cat"
pattern2 = "bird"
string = "dog runs to cat"
print(re.search(pattern1, string))  # <_sre.SRE_Match object; span=(12, 15), match='cat'>
print(re.search(pattern2, string))  # None

findall
前面我们说的都是只找到了最开始匹配上的一项而已, 如果需要找到全部的匹配项, 我们可以使用 findall 功能. 然后返回一个列表. 注意下面还有一个新的知识点, | 是 or 的意思, 要不是前者要不是后者.

# findall
print(re.findall(r"r[ua]n", "run ran ren"))
>>>  ['run', 'ran']# | : or
print(re.findall(r"(run|ran)", "run ran ren"))
>>>  ['run', 'ran']

replace
我们还能通过正则表达式匹配上一些形式的字符串然后再替代掉这些字符串. 使用这种匹配 re.sub(), 将会比 python 自带的 string.replace() 要灵活多变.

print(re.sub(r"r[au]ns", "catches", "dog runs to cat"))     # dog catches to cat

split
再来我们 Python 中有个字符串的分割功能, 比如想获取一句话中所有的单词. 比如 “a is b”.split(" "), 这样它就会产生一个列表来保存所有单词. 但是在正则中, 这种普通的分割也可以做的淋漓精致.

print(re.split(r"[,;\.]", "a;b,c.d;e"))
>>> ['a', 'b', 'c', 'd', 'e']

compile
最后, 我们还能使用 compile 过后的正则, 来对这个正则重复使用. 先将正则 compile 进一个变量, 比如 compiled_re, 然后直接使用这个 compiled_re 来搜索.

compiled_re = re.compile(r"r[ua]n")
print(compiled_re.search("dog ran to cat"))
>>> <_sre.SRE_Match object; span=(4, 7), match='ran'>

小技巧

快速结构性代码对齐：
Windows下使用 Ctrl + [
Mac 下使用 command + [
要停止程序，使用 ctrl + c 终止程序

更多学习笔记关于…
Python3多进程（Multiprocessing）
Python3多线程（Threading）
Python3窗口视窗（Tkinter）
…

学习资料链接:

1、参考学习资料.
2、参考学习资料.

Python 学习笔记本一一相关推荐

c语言python学习笔记本,【答疑】python编程需要怎样的电脑配置啊？ - 视频教程线上学...
lumion 9.0需要电脑配置 2019-03-08 浏览量:11503 提问者:小曼回答: 下面是我大力推荐的一套lumion 9.0的电脑配置,预算大概一万左右,运行起来毫无压力.CPUInt ...
自学python编程笔记本推荐-python自学教程 | 3万字为你详解每个重要知识点
本文目录: 什么是Python? Python的用途是什么? 如何安装Python? 为什么选择Python? R与Python 学习Python的最佳方法什么是顶级Python IDE 哪个是最适 ...
涵盖 14 大主题！最完整的 Python 学习实例集来了！
机器学习.深度学习最简单的入门方式就是基于 Python 开始编程实战.最近闲逛 GitHub,发现了一个非常不错的 Python 学习实例集,完全是基于 Python 来实现包括 ML.DL 等领域 ...
收藏 | 49 个 Python 学习资源
点击⬆️"小詹学Python",选择"星标"公众号重磅干货,第一时间送达本文为不同阶段的Python学习者从不同角度量身定制了49个学习资源. 初学者 We ...
Python学习教程（Python学习路线）：如何正确使用Pandas库提升项目的运行速度？...
Python学习教程:如何正确使用Pandas库提升项目的运行速度? 如果你从事大数据工作,用Python的Pandas库时会发现很多惊喜.Pandas在数据科学和分析领域扮演越来越重要的角色,尤其是 ...
Python学习(14)--内置函数
Python学习(14)--内置函数 1.Python内置函数在Python中有很多的内置函数供我们调用,熟练的使用这些内置函数可以让编写代码时事半功倍,所谓内置函数就是那些Python已经预定义并 ...
中软python编码规范考试试题_这些常见的python学习问题，你中枪了吗？
我们在学习的过程中,总会遇到这样那样的问题,今天,中软国际(厦门)的小编来为大家分析学习python的过程中常碰见的几个问题. 首先,小编要讲下python初学者的一个整体学习规划: 1.定位了解市 ...
自学python编程笔记本推荐-这件神器，每个 Python入门学习者都值得一试
原标题:这件神器,每个 Python入门学习者都值得一试灰常实用的一篇文章,看完你会来点赞滴. 不论你是刚开始学 Python,还是正在啃数据分析的骨头,对你来说,不断在各种命令行窗口和编辑器里切来 ...
Python学习日志12 - 办公自动化
Python学习日志 RBHGO的主页欢迎关注温馨提示:创作不易,如有转载,注明出处,感谢配合~ 目录文章目录 Python学习日志目录前言进入正题 Python学习日志12课 - 办公自动 ...

Python 学习笔记本一一