最近刚刚做完一个基于深度学习框架的医学图像识别任务，深知要弄好项目，一定要打好代码基础，要不然真的是心力交瘁，总结一下使用到的模块和函数，还有一些Python的基础知识，本篇讲解基础知识，模块部分会分开来讲，目录列表如下：
内容列表
1.Python基础知识
Python是一种高级的，动态类型的多范型编程语言。Python编写的程序有一个很大的优点就是便于理解，可以用很少的行数来表达你想要的效果，还有一个优点就是可以引用现成的模块来达到事半功倍的效果，不过要注意，Python的版本是一个大问题，目前虽然 python2 和python3 都应用很广泛，但是要注意2020年初 python2 就要下线了，所以尽量使用 python3 来写代码吧！
1.基本数据类型与基本运算符
和大多数编程语言一样，Python拥有一系列的基本数据类型，比如整型、浮点型、布尔型和字符串等。这些类型的使用方式和在其他语言中的使用方式是类似的。
1.数字（整形与浮点型）
x = 4
print type(x) # 输出为："<type 'int'>"
print x # 输出为："4"
print x + 1 # 加，输出为："5"
print x - 1 # 减，输出为："3"
print x * 2 # 乘，输出为："8"
print x / 2 # 除，输出为："2"
print x % 2 # 取余，输出为："0"
print x ** 2 # 取幂，输出为："16"
print x // 3 # 取除数，输出为："1"
x += 1
print x # 等价于x = x + 2，输出为："5"
x *= 2
print x # 等价于x = x * 2，输出为："8"
y = 2.5
print type(y) # 输出为："<type 'float'>"
print y, y + 1, y * 2, y ** 2 # 输出为："2.5 3.5 5.0 6.25"，可以看出浮点数的运算得到的也是浮点数
2.布尔型
注意：python中，0，空字符串" "和none布尔型都为False；其他数值与非空字符串布尔型为True。
t = True
f = False #注意：True 与 False 首字母都要大写
print type(t) # 输出为："<type 'bool'>"
print t and f # 逻辑与操作，输出为："False"
print t or f # 逻辑或操作，输出为："True"
print not t # 逻辑非操作，输出为："False"
print t != f # 逻辑异或操作，输出为："True"
3.字符串
hello = 'hello'
world = "world" # 字符串文字可以使用单引号' '或双引号" "
print hello # 输出为："hello"
print hello,world # 逗号代替空格，输出为："hello world"
print len(hello) # 字符串长度，输出为："5"
hw = hello + ' ' + world
print hw # 字符串可以进行串联,输出为："hello world"
hw12 = '%s %s %d' % (hello, world, 12)
print hw12 # sprintf 格式字符串样式,输出为："hello world 12"
字符串也有一些函数可以进行表达
s = "hello"
print s.capitalize() # 首字母大写，输出为："Hello"
print s.upper() # 将字符串全部大写，输出为："HELLO"
print s.rjust(7) # 将字符串置于右端，左边补空，输出为：" hello"
print s.center(7) # 将字符串置于中间，两边补空，输出为：" hello "
print s.replace('l', '(ell)') # 将原字符串部分置换成另一类，可以为数字，输出为："he(ell)(ell)o"
print ' world '.strip() # 去除前置和尾置空格; 输出为："world"
4.基本运算符
除去上文提到的简单算数运算符、逻辑运算符与赋值运算符，这里提一下剩下的几种运算符还有赋值运算符的变形。
比较运算符：
a = 21
b = 10
c = 0
print a == b # 等于运算符，输出为："False"
print a != b # 不等于运算符，输出为："True"，这里不等于也可以用 <>
print a > b # 大于比较运算符，输出为："True"
print a >= b # 大于等于比较运算符，输出为："True"
位运算符(这里位运算符是将数字转换成二进制再进行逻辑操作)：
a = 60 # a = 0011 1100
b = 13 # b = 0000 1101
print a&b # 按位与操作，输出为："12" a&b = 0000 1100
print a|b # 按位或操作，输出为："61" a|b = 0011 1101
print a^b # 按位异或操作，输出为："49" a^b = 0011 0001
print ~a # 按位非操作，输出为："-61" ~a = 1100 0011
print a << 2 # 按位向左移动，高位丢弃，低位补0，输出为："240" a << 2 = 1111 0000
print a >> 2 # 按位向右移动，低位丢弃，高位补0，输出为："15" a >> 2 = 0000 1111
成员运算符：
a = 1
list = [1, 2, 3, 4, 5 ];
print a in list #判断指定序列内是否有值，输出为："True"
print a not in list #输出为："False"
身份运算符：
a = 20
b = 20
print a is b #判断两个标识符是否引用同一个对象，输出为："True"
print a is not b #输出为："False"
赋值运算符：
a = True
print a and "a = T" or "a = F" #输出为："a = T"
#1.计算a and b时，若a是False，则结果为False，返回a；若a是True，则结果取决于b，返回b
#2.计算a or b时，若a是True，则结果为True，返回a；若a是False，则结果取决于b，返回b
#所以 a and "a = T" 返回"a = T"
# "a = T" or "a = F" 返回"a = T"
这里继续说一下运算符的优先级，一般为算术运算符>位运算符>比较运算符>赋值运算符>身份运算符>成员运算符>逻辑运算符。
2.复合数据类型
基本的复合数据类型包括：列表List，元祖Tuple，字典Dict与集合Set：
1.列表
列表等同于数组，并且列表是可以改变长度的，并且内部元素可以是不同类型的。
xs = [3, 1, 2] # 创建列表
print xs, xs[2] # 通过索引查找列表内元素，输出为："[3, 1, 2] 2"
print xs[-1] # 负数从列表末尾开始数，输出为："2"
xs[2] = 'foo'
print xs # 列表可以包含不同类型的元素，输出为："[3, 1, 'foo']"
xs.append('bar')
print xs # 将新元素添加到列表的末尾，输出为："[3, 1, 'foo', 'bar']"
xs.insert(3,'beer')
print xs # 将新元素添加到索引位置，输出为："[3, 1, 'foo', 'beer' 'bar']"
x = xs.pop()
print x, xs # 默认删除并返回列表的最后一个元素，输出为："bar [3, 1, 'foo', 'beer']"
xs[0],xs[1] = xs[1],xs[0]
print xs #交换列表内两个索引位置的值，输出为："[1, 3, 'foo', 'beer']"
列表切片：
nums = range(5)
print nums # range是一个内置函数，用于创建整数列表，输出为："[0, 1, 2, 3, 4]"
print nums[2:4] # 从索引2到4获取切片，注意不包含索引4; 输出为："[2, 3]"
print nums[2:] # 从索引2到结尾获取切片，输出为："[2, 3, 4]"
print nums[:2] # 从开始到索引2获取切片，输出为："[0, 1]"
print nums[:] # 得到完整列表，输出为："[0, 1, 2, 3, 4]"
print nums[:-1] # 切片索引也可以为负数，输出为："[0, 1, 2, 3]"
nums[2:4] = [8, 9]
print nums # 将新子列表分配给切片，输出为："[0, 1, 8, 9, 4]"
使用enumerate函数可以对列表获取索引：
animals = ['cat', 'dog', 'monkey']
for idx, animal in enumerate(animals):
print '#%d: %s' % (idx + 1, animal)
#输出为: #1: cat
# #2: dog
# #3: monkey
列表内元素更新：
#直接循环
nums = [0, 1, 2, 3, 4]
squares = []
for x in nums:
squares.append(x ** 2)
print squares # 输出为：[0, 1, 4, 9, 16]
#列表内直接进行循环
squares = [x ** 2 for x in nums]
print squares # 输出为：[0, 1, 4, 9, 16]
#可以添加更多限定条件
squares_part = [x ** 2 for x in nums if x % 2 == 0]
print squares_part # 输出为：[0, 4, 16]
2.字典
字典可以用来储存键key与值value，但是字典是无序的，在一个字典中键不能重复，列表不能作为键存在。
d = {'cat': 'cute', 'dog': 'furry'} # 使用一些数据创建一个新字典
print d['cat'] # 从字典中获取条目，输出为："cute"
print 'cat' in d # 检查字典是否有给定的键，输出为："True"
d['fish'] = 'wet'
print d['fish'] # 在字典中增添条目，输出为："wet"
d['cat'] = 'lovely'
print d['cat'] #可以对原有键更改其值，输出为："lovely"
print d['monkey'] # 出现错误，字典中没有键名为"monkey"
print d.get('monkey', 'N/A') # 获取具有默认值的键，若字典内没有该元素，则输出为"N/A",否则为None，输出为："N/A"
print d.get('fish', 'N/A') # 获取具有默认值的键，但是字典内有该键，输出为："wet"
del d['fish'] # 从字典内移除该键
print d.get('fish', 'N/A') # "fish"不再存在在字典内，输出为："N/A"
遍历字典内的键：
#直接通过循环获得
d = {'person': 2, 'cat': 4, 'spider': 8}
for animal in d:
legs = d[animal]
print 'A %s has %d legs' % (animal, legs)
# 输出为: A person has 2 legs
# A spider has 8 legs
# A cat has 4 legs
#使用iteritems函数获得
for animal, legs in d.iteritems():
print 'A %s has %d legs' % (animal, legs)
# 输出为: A person has 2 legs
# A spider has 8 legs
# A cat has 4 legs
字典内也可以进行循环更新键值：
nums = [0, 1, 2, 3, 4]
even_num_to_square = {x: x ** 2 for x in nums if x % 2 == 0}
print even_num_to_square # 输出为："{0: 0, 2: 4, 4: 16}"
3.元组
元组是一个值的有序列表（不可改变），从很多方面来说，元组和列表都很相似，和列表最重要的不同在于，元组可以在字典中用作键，还可以作为集合的元素，而列表不行。
d = {(x, x + 1): x for x in range(10)} # 通过一个元组创建一个字典
print d # 输出为："{(0, 1): 0, (1, 2): 1, (3, 4): 3, (2, 3): 2, (4, 5): 4}"
t = (5, 6) # 创建一个元组
print type(t) # 输出为："<type 'tuple'>"
print d[t] # 输出为："5"
print d[(1, 2)] # 输出为："1"
元祖创建即不可改变，除非元组内存入了列表：
t = ('a', 'b', ['A', 'B'])
L = t[2] # 注意元祖取值使用[]
L[0] = 'x'
L[1] = 'y'
print t # 输出为："('a', 'b', ['x', 'y'])"
当元组内元素个数不同时，元组内表示方法也不同：
t = ()
print t # 输出为："()"
t = (1)
print t # 当输入元素只有一个时，输出为整数，并非元组，输出为："1"
t = (1,)
print t # 输出为："(1,)"
4.集合
集合是独立不同个体的无序集合，集合区分于字典的是集合内元素没有键值value，使用()时区分于元组的是里面需要添加列表。
animals = set(['cat', 'dog']) #创建集合为调用set()并传入一个列表，列表内元素为集合内元素，此处也可以用animals = {'cat', 'dog'}
print 'cat' in animals # 检查元素是否存在于集合内，输出为："True"
print 'fish' in animals # 输出为："False"
animals.add('fish')
print 'fish' in animals # 向集合内增添元素,输出为："True"
print len(animals) # 集合内元素个数，输出为："3"
animals.add('cat')
print len(animals) # 向集合内增添一个原本存在的元素，则没有任何效果，输出为："3"
animals.remove('cat')
print len(animals) # 从集合内删除一个元素，输出为:"2"
集合内遍历元素，因为集合内元素是无序的，所以并不能假设顺序：
animals = {'cat', 'dog', 'fish'}
for idx, animal in enumerate(animals):
print '#%d: %s' % (idx + 1, animal)
#输出为: #1: fish
# #2: dog
# #3: cat
集合内元素更新：
from math import sqrt
nums = {int(sqrt(x)) for x in range(30)}
print nums # 输出为："set([0, 1, 2, 3, 4, 5])"
3.函数与判断语句
1.定义函数
Python中使用def来定义函数：
def sign(x):
if x > 0:
return 'positive'
elif x < 0:
return 'negative'
else: # 使用if-elif-else进行判断语句
return 'zero'
for x in [-1, 0, 1]: #使用for在列表内从前向后循环取值代入x
print sign(x)
# 输出为: negative
# zero
# positive
通常函数内可以自己定义参数的数值或布尔值，也可以在使用函数时自己选择参数值：
def hello(name, loud=False):
if loud:
print 'HELLO, %s' % name.upper()
else:
print 'Hello, %s!' % name
hello('Bob') # 输出为："Hello, Bob"
hello('Fred', loud=True) # 输出为："HELLO, FRED!"
2.一些条件判断语句与循环语句
除了上文提到的if判断语句与for循环语句，还有while循环语句、break退出循环语句、continue继续循环语句、assert断言语句：
#while循环语句：
N = 10
x = 0
L = []
while x < N: #当限定条件为True时，跳出循环
L.append(x)
x += 1
print L #输出为："[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
#break退出循环：
sum = 0
x = 1
while True:
sum +=x
x += 1
if x > 100:
break #当判断结果为True时，终结循环
print sum #输出为："5050"
#continue继续循环：
L = [75, 98, 59, 81, 66, 43, 69, 85]
sum = 0.0
n = 0
for x in L:
if x < 60:
continue #当出现判断结果为True时，跳出本次循环，进入下一次循环
sum +=x
n += 1
print sum #输出为："474.0"
#assert断言语句：
#assert语句为当assert后的语句判断为False时，自动报错
#assert expression ==> if not expression:
# raise AssertionError
a_str = 'this is a string'
print type(a_str) #输出为："<type 'str'>"
assert type(a_str)== str
assert type(a_str)== int #输出报错
4.类
Python对于类的定义是简单直接的，类用来描述具有相同的属性和方法的对象的集合，它定义了该集合中每个对象所共有的属性和方法，对象是类的实例：
class Greeter(object):
'类的帮助信息' # 类文档字符串
def __init__(self, name): # 类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
# self代表类的实例，self在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。
self.name = name # 创建一个变量例子
def greet(self, loud=False):
if loud:
print 'HELLO, %s!' % self.name.upper()
else:
print 'Hello, %s' % self.name
def prt(self):
print(self)
print(self.__class__)
g = Greeter('Fred') # 构造Greeter类的实例
g.greet() # 调用实例方法，输出为:"Hello, Fred"
g.greet(loud=True) # 输出为:"prints "HELLO, FRED!"
g.prt() # self 代表的是类的实例，代表当前对象的地址，输出为:<__main__.Greeter object at 0x000000000D7E57F0>
# self.__class__ 则指向类,输出为: <class '__main__.Greeter'>
print Greeter.__doc__ # 返回类文档字符串，输出为："类的帮助信息"
print Greeter.__name__ # 返回类的名字，输出为："Greeter"
print Greeter.__module__ # 返回类定义所在的模块，输出为："__main__"
print Greeter.__bases__ # 返回类的所有父类构成元素，输出为："(<type 'object'>,)"
print Greeter.__dict__ # 返回类的属性（包含一个字典，由类的数据属性组成），输出为："{'__module__': '__main__', 'greet': <function greet at 0x000000000D956128>, 'prt': <function prt at 0x000000000D9566D8>, '__dict__': <attribute '__dict__' of 'Greeter' objects>, '__weakref__': <attribute '__weakref__' of 'Greeter' objects>, '__doc__': '\xe7\xb1\xbb\xe7\x9a\x84\xe5\xb8\xae\xe5\x8a\xa9\xe4\xbf\xa1\xe6\x81\xaf', '__init__': <function __init__ at 0x000000000D9565F8>}"
类有一种机制叫继承，通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类：
class Parent: # 定义父类
parentAttr = 100
def __init__(self):
print "调用父类构造函数"
def parentMethod(self):
print '调用父类方法'
def setAttr(self, attr):
Parent.parentAttr = attr
def getAttr(self):
print "父类属性 :", Parent.parentAttr
class Child(Parent): # 定义子类,将对象设为父类
def __init__(self):
print "调用子类构造方法"
def childMethod(self):
print '调用子类方法'
c = Child() # 输出为："实例化子类"
c.childMethod() # 输出为："调用子类的方法"
c.parentMethod() # 输出为："调用父类方法"
c.setAttr(200) # 输出为："再次调用父类的方法 - 设置属性值"
c.getAttr() # 输出为："再次调用父类的方法 - 获取属性值"
先初步写到这里，接下来大概讲一下常用Module：numpy，matplotlib，os，cv2，pandas之类的！
参考资料
- CS231n课程笔记翻译：Python Numpy教程：https://zhuanlan.zhihu.com/p/20878530?refer=intelligentunit
- 菜鸟教程：http://www.runoob.com/
- CSDN其他大佬的博客
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
