Python 学习笔记

简单记录下在学习py中的历程

1.编辑器推荐使用 Sublime  ， IDE推荐使用 PyCharm，强烈推荐Pycharm，没有为什么，新手友好
2.python中输入输出函数  print();/input(); 其中input()和matlab中相似
3.python中if/else不加小括号和大括号，但是后面必须加冒号，感觉和matlab有点像又不像
4.print(r'\\')中的r只要出现，不管是三个引号还是一个引号，中间的转义字符全部失效
5.用于计算字符串长度使用len()函数
6.使用print格式化输出真奇葩 print('hello %s, the number you have dailed %d is power off' %('yohao',1383843838))
7.Python 列表->[ ] / 元组->（）/ 字典->{ } 所有索引都是 [ ]
   Matlab 所有涉及到矩阵的都是[ ]  所有索引的都是（）
8.print()  里面有几个控制参数 sep控制参数之间的符号，默认为空格，end控制print结尾的符号，默认 '\n'
9.temp = a if a > b else b   py中三目运算符
10. b = a[:]  即把list a中的数据全部复制给b，但是b=a却并不是复制，而是把b的指针指向a，因此a发生变化b也一定会变化
11.PY中复杂的time 和datetime模块

	import time
	import datetime
	
	# 返回距1970年过了多长时间
	print(time.time())

	# 结构体返回所有时间信息
	print(time.localtime())
	print(time.localtime(time.time()))

	# 返回西方格式所有时间信息
	print(time.asctime())

	# 返回标准格式所有时间信息 秒精确至小数点后四位
	print(datetime.datetime.today())
	# 返回标准格式所有时间信息
	print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime()))

	# 返回年月日
	print(datetime.date.today())
	# 返回指定日期
	print(datetime.date(1994,4,21))

12.py中可以使用\来作为一句的连接符，但是所有括号均不需要使用连接符，直接逗号隔开换行即可
13.matlab中 a[2:end] 和 py中 a[2:] 所起的作用是类似的，py中没有end关键字。可以使用切片操作复制整个list
14.单行注释# 和 多行注释 ''' '''
15.a = b = c = 1
16.a,b,c,d,e =  1,2,3,'a','k'
17.对于字符串  + 表示连接两个字符串  * 表示重复符号
    'a' + 'b'->'ab'   'a' * 2 -> 'aa'
18.列表的索引list[1:5:2] 即取1,3两位第三位表示步长，与matlab中的不同 matlab中 中间表示步长 
    仅当索引时才可以使用[ 1:5:2 ]冒号操作，一定注意和range()中的逗号区分开
    list =[ 1:5:2 ] 如上定义是不对的，但是list = range(1,5,2)是对的
19.区别range(1,5,3)同样，第三位表示步长，只不过range中用的是逗号，而不是冒号
20.list使用最常见，使用[ ]定义，tuple相当于只读list，使用()定义
21.dictionary不是根据偏移来找的而是根据键值来找的，使用{ }定义，key：value  key不一定要加引号
22.list/tuple/dictionary索引都是使用[ ]来进行的，前两个是使用偏移，后面那个是根据key值来找的， 
23.dictionary的添加删除和list比起来比较特殊
24.逻辑与/或/非 and/or/not
25.py成员运算符 in/not in 如果在指定的序列中找到值就返回True否则返回False 	/
		       如果在指定的序列中没有找到值就返回True否则返回False
26.	a = 10
	b = 20
	list = [10,25,32,26,14]

	if b in list:
    	  print(True)
	else:
    	  print(False)			

27.py身份运算符 is/is not  用来判断两个标识符是不是处于同一个内存空间，即is两边是不是指向同一个地址的两个指针
    a is b 相当于 id(a)==id(b)，id() 能够获取对象的内存地址。 而 == 是用来判断两个值是否相等
	a = [11,123,'a','f','qqqq']
	b = a

	if a is b :
    	  print('First True')
	else:
    	  print('First False')

	c = a[:]

	if a is c :
    	  print('First True')
	else:
    	  print('First False')
28.至于为什么 初始化时 
	a = 123
	b = 123
使用a is b 返回结果为True，即id(a) = id(b)，解释是，py出于对性能的考虑，但凡是不可变对象，
在同一个代码块中的对象，只有是值相同的对象，就不会重复创建，而是直接引用已经存在的对象。
29. if __name__ == '__main__':  简单解释，每个文件单独测试时__name__ 都是__main__ ，所以当 当前文件import
其他文件时如果在被import文件中有这句话，下面的代码就不会运行，因为import其他文件的这个文件__name__ 是__main__ 
30.pass是为了保持语法的完整性，实际上什么都不做
31.循环while/else for/else 其中的else 有时候超级有用千万别忘了，break后不再执行else
32.list骚操作
	lit = [1,2,3,'a','q']
	print(lit[::-1])
    表示从后往前依次输出lit中的元素
33.pip安装Packet时要使用具有管理权限的cmd，pip有关指令菜鸟网上都有
34.numpy 是一个数学矩阵库有关的Packet，很重要，具体使用时可上菜鸟网查看
35.使用 from numpy import * 	这种方式会更好一些，避免了每次开头都得输一次Packet的名字
    但是import numpy 这种方式更直观，且好理解
36.生成随机数	num = random.randint(a,b)  首先得import random的packet才能调用，生成介于a与b之间(边界包含)
    的一个随机数作为返回值返回
37.生成3*3矩阵一种新的方法 	arr = [[random.randint(1,100) for i in range(3)] for _ in range(3)] 括号必须包含否则出错
    感觉像是在写英语句子一样
38. for _ in range(3) /  for i in range(3) 对比这两个不难发现，我们可以是用_来代替i，前提是后面没有用到i，不然没有任何意义
39.调用numpy库来实现任意矩阵的操作，NumPy 通常与 SciPy（Scientific Python）和 Matplotlib（绘图库）一起使用， 
    这种组合广泛用于替代 MatLab，是一个强大的科学计算环境，有助于我们通过 Python 学习数据科学或者机器学习
40.a = np.arange(20) 首先调用numpy packet，这句指令生成一个一维数组0-19，共计20个数
    a = np.arange(10，20) 生成一个一维数组10-19共计20个数
41.a.ndim表示计算数组a的秩
42.a.reshape(4,5)重新调整a的维度，前提是各维度数值相乘后必须等于原向量个数，如上是2维，还可以调整成三维等等
43.a = np.array([1,2,3]),把一个一维或者多维list扔到np.array里面即可输出对应的数组
44.a.shape返回数组a的维度相当于Matlab中的size，返回值是一个元组(2,3)
45.a = np.empty([3,3]，dtype=int)创建一个3*3的未初始化的数组，即数组元素为垃圾,不加dtype的话默认为浮点型
    于是会出现0./.1 即表示小数点后/前为0都省略了
46.a = np.zeros([3,3]，dtype=int) 和 a = np.ones([3,3]，dtype=int) 用法都同上，和Matlab中的差不多，先开辟空间要快得多
47.使用numpy库生成的矩阵中间是没有逗号来作为间隔的，而使用list伪造的矩阵必须要有逗号，这就是区别
48.a =  np.eye(5,dtype=int)生成一个对角阵，元素都是int型的
49.生成一个随机的3*3矩阵的两种方法 ，如下
    a = np.random.randint(1,100,(3,3)) 			其中(3,3)/[3,3]都可以
    a = np.random.randint(1,100,9).reshape(3,3)
    上下两个都是等价的
    a = np.random.randint() np中的randint()方法入口参数除了起始位和终止位，还包括size，具体可查看，非np中的
    randint()函数入口参数仅有两个起始位和终止位
50.numpy中有关于矩阵的代数运算的几乎所有函数，很方便，但是对于矩阵 a +-/* b 却是Matlab中的 +-.*./操作，谨记
51.随机数  a = random.random()	生成0-1之间的随机数
	b = random.uniform(1,100)	生成1-100之间的随机数
	c = random.randint(1,100)	生成1-100之间的随机整数
    前提是一定要import random模块
52.关于dict类型转换，三种数组类型，list/tuple/dict最常用的当然是list，而tuple和list区别也不大，因此最难的是dict
    不光是定义奇葩， a = {'name':'yohao','age':22,'region':'henan'} 几乎所有key值都要加引号，而value
    大多数都加引号，除了一些数字，下面三种dict类型转换方法，由于dict()是函数，所以必须加小括号
    	dict(a='a', b='b', t='t')     	              # 传入关键字
	{'a': 'a', 'b': 'b', 't': 't'}

	 dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典  ----------->这种映射方式很重要
	{'one': 1, 'two': 2, 'three': 3}

	 dict([('one', 1), ('two', 2), ('three', 3)])     # 可迭代对象方式来构造字典
	{'one': 1, 'two': 2, 'three': 3}

    明显1和3不常用，一般用的最多的是和list有关的，即将list转化为dict，那就是2了，我们一般可以得到两个list，比如
    list1是name，list2是对应的年龄，我们需要把两个list转化为一个dict便于调用，这时候用2是最舒服的
    下面还有好多东西需要延伸
53.关于上面的2，zip()是一个函数，见名知意，压缩函数，较少内存浪费，这些我们都不需要管，只需要知道他和dict搭配
    是绝佳，zip()函数入口参数是list，为了和dict搭配最好是两个list，便于映射，该函数返回值好像是一个对象， 我们用不到
    直接这样使用dict( zip( [1,2,3] , [4,5,6] ) ) 就将两个list映射起来转换为dict了输出为{1: 4, 2: 5, 3: 6}，但是注意key值不要重复
    重复了的话同一个key值以最后一个value值为准，
54.py的逻辑运算符比较奇葩，and/or/not中仅有not是和c中的一样， and/or用在if中可能没什么事情，如下
    if a and b  ，a和b的值必须都为真才能往下走，也就是说a and b 后我原以为值为True/False 其实并不是，如下

    x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。
    x or y	布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。
    not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。
    
    如果想使运算后结果为True/False的话，需要bool()类型转换，所以不要轻易将逻辑运算过后的值赋值给另一个值
    很可能出现预想不到的Bug，但是在if的判断中是没有什么问题的

55.py的按位取反也是个大坑，如下
    按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1
    重点在最后一句 ~x 类似于 -x-1，举例 60-> 0011 1100 按位取反  1100 0011 本来应该是195的但是，在py中算出来却是
    -61，即满足~x = -x-1，至于理由百度一下即可，涉及到原码反码补码，不难回想起来，第一位表示正负 
    0+ 1- 证书原反补码都一样，负数反码是源码取反，补码是源码取反加一。具体去百度下吧，不想理解了，真麻烦
    https://blog.csdn.net/u011452172/article/details/80822402
56.方法join和split，split用于分割，join用于联合 如下
    a = 'this is a string'
    b = a.split() 即将字符串分隔开，默认空格为分隔符，可以指定其他，分出来之后是一个list，里面都是字符串   
    ans = '-'.join(a)  这个格式比较奇怪，连接的字符在前，然后引用join的方法，入口参数为需要join的字符串
57.	integer_list = map(int, input().split())
    	temp = tuple(integer_list)
	可用于专门解决输入全部为int类型数据的情况，如果使用split那种方法的话，tuple出来都是字符串，不好处理
  	而这种方法tuple里面都是int类型的数字而不是字符串
58.如何对字符串进行插入删除等操作，一般来说都是对list/tuple/dict进行插入删除等操作，而字符串由于是常量，
    无法对一个常量进行操作，于是有以下两种方法
    1.把一个str转换成list然后进行insert/del操作，最后使用join操作即可
    2.切片复制，分成两段，把需要insert的加进去即可，不过如果str长的话这种方法很不占优势，建议使用1
59.关于index和find，简单说下，在list中只能使用index，而在字符串查找过程中index和find都可以使用
    而index查找成功返回数字，和find一样，但是查找失败却会抛出一个错误，fand查找失败返回-1
    所以能使用find尽量不要使用index
60.关于isdigit/isnumeric 即用来判断字符串是不是仅由数字组成，使用1不要使用2，2是针对特定编码字符的
61.关于字符串都有一堆判断函数isdigit/isnumeric/islower/... 熟练使用
62.有一个bug，	lst.extend(input())		lst.extend(input().split())	lst是一个list变量
    第一个lst不是我们想要的结果，第二个才是我们想要的结果  若想使用一，可以改用  lst.append(input())
    原因是extend前后两个参数都必须是list类型的，而input并不是list所以输出是类似这个的  	['a', 'a', 'a']
    input().split()  是一个list 所以第二个才能成立
63.join是将list/tuple中的字符串以一定的字符连接起来   如 '-'.join(lst) 表示将lst中的元素以-连接起来
64.关于文件这块还不是很熟悉，会简单的即可，等到以后有需要再练
65. w/w+/r(默认)	+表示既读又写 不加的话仅表示读或者写 
    w+ 表示如果没有文件就创建，如果有就从头开始写，原有内容会被删除，不能同时 写入和读取
    w   表示如果没有文件就创建，如果有就从头开始写，原有内容会被删除，但是仅可以写入
    r    默认情况只读
    记得在open的时候，这三个需要使用字符串形式，否则会出bug
66.对文件操作通常就是open然后获取文件指针，处理完后文件指针.close即可，一定要记得close，不然肯定会出bug
67.在读取的时候，文件指针在最后面，然后可以在后面写入
68.	filename = input('Please input filename : ')
	file = open(filename,'w')
	ch = input('Please input something : ')
	while '#' not in ch:
    	  file.write(ch)
    	  ch = input( 'Please input something again : ' )
	file = open(filename,'r')s
	print(file.read())
	file.close()
69.对于函数有很多内置的操作
    __doc__ 用来输出函数中三个引号之间的内容，也称之为多行注释	doc本来就是表示文档的意思
    __name__ 则可以用来输出函数的名字
    __init__ 类似于c++中的构造函数，在实例化时自动调用
    还有一些其他的类似操作，不过一般都是函数名直接调用的
70.关于__init__ 有诸多需要讲的
    1.未显示调用的话在实例化时被隐式调用
    2.	class Complex:
    	  def __init__(self,rea,ima):
        	    self.r = rea
        	    self.i = ima
	x = Complex(3.0,4.5)
	print(x.r,x.i)
    如上则是显示调用，self是自动出现的，后面两个参数则是添加的
71.类/对象/方法
    如上，class后面紧跟的是类，对象是类实例化后的产物，a = Complex  a即为Complex的对象，方法则是类中的函数
    对象可以引用方法，由类定义一个对象称之为类的实例化，在类中定义方法时会自动出现self参数，表示和普通的函数不同
    类中的函数有self参数，称之为方法，类外面的函数则是普通的函数。还有，在类实例化时，构造函数即被自动调用，
    当然也可以显示调用，如上。
72.实例如下
    终于明白self指针的妙用，关键时刻太重要了，self可以调用class内的变量和方法，便于初始化和其他调用，
    免得在class内部无法实例化而不能调用变量和方法，self指针类似于c++中的this指针
class People:

    #定义基本属性
    name = ''
    age = 0

    #定义私有属性，私有属性在类外部无法直接进行访问
    #__开头表示私有属性
    __weight = 0

    #构造函数
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w

    #方法
    def speak(self):
        print('my name is %s and my age is %d' %(self.name,self.age))
        print('my weight is %d' %self.__weight )

#实例化
yohao = People('yohao',22,80)
yohao.speak()

73.继承，既然面向对象，必然可以继承，子类继承父类，或者说派生类继承基类
实例如下

#子类继承父类，括号里面表示父类，外面是子类
class Student(People):
    #定义基本属性
    grade = 0
    #构造函数
    #直接调用父类构造函数
    def __init__(self,n,a,w,g):
        People.__init__(self,n,a,w)
        self.grade = g
    #重新改写方法，由于__weight在父类中属于私有类型故在子类中无法调用，原因是根本找不到
    def speak(self):
        print('My name is %s and I am %d years old.I am studying in grade %d' \
                  %(self.name,self.age,self.grade))
#实例化
yohao = Student('yoaho',22,80,9)
yohao.speak()

74.__init__ : 构造函数，在生成对象时调用
    __del__ : 析构函数，释放对象时使用
    这两个最常用
75.