Python 学习笔记本一一

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

学习的知识

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= False
    else:
        pass
    print('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':
        break
    else:
        pass
    print('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':
       continue
    else:
        pass
    print('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以后，系统就会新建一个文件（要用写入的类型），再次运行后，文件中就会写入ssss

try:
    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:y

ssss  #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)
>>>
  1
  2
  3
  4
  5
  6
  7
  8
  9  

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

for i in range(10):
    print(i)
>>>
  0
  1
  2
  3
  4
  5
  6
  7
  8
  9

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 = max
        self.n, self.a, self.b = 0, 0, 1

    def __iter__(self):
        return self

    def __next__(self):
        if self.n < self.max:
            r = self.b
            self.a, self.b = self.b, self.a + self.b
            self.n = self.n + 1
            return r
        raise 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, 1
    while max:
        r = b
        a, b = b, a+b
        max -= 1
        yield 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 = 0
    for grade in grades:
        total_grade += grade
    print(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 third

text='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=18
    def add(self,x,y):
        print(self.name)
        result = x + y
        print(result)
    def minus(self,x,y):
        result=x-y
        print(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=18
    def __init__(self,name,price,height,width,weight):   # 注意，这里的下划线是双下划线
        self.name=name
        self.price=price
        self.h=height
        self.wi=width
        self.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=18
    def __init__(self,name,price,hight=10,width=14,weight=16): #后面三个属性设置默认值,查看运行
        self.name=name
        self.price=price
        self.h=hight
        self.wi=width
        self.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, 是用来匹配字符的一种工具. 在一大串字符中寻找你需要的内容. 它常被用在很多方面, 比如网页爬虫, 文稿整理, 数据筛选等等. 最简单的一个例子, 比如我需要爬取网页中每一页的标题. 而网页中的标题常常是这种形式。