python点点滴滴
1 self
使用python编程实现邮箱登录时，遇到使用self的情况，在此做简要记录。
在介绍Python的self用法之前，先来介绍下Python中的类和实例……
面向对象最重要的概念就是类（class）和实例（instance），类是抽象的模板，比如学生这个抽象的事物，可以用一个Student类来表示。
实例是根据类创建出来的一个个具体的“对象”，每一个对象都从类中继承有相同的方法，但各自的数据可能不同。
1.1 类
以Student类为例，在Python中，定义类如下：
class Student(object):
pass
（Object）表示该类从哪个类继承下来的，Object类是所有类都会继承的类。
1.2实例
定义好了类，就可以通过Student类创建出Student的实例，创建实例是通过类名+()实现：
student = Student()
1.3 __init__方法
由于类起到模板的作用，因此，可以在创建实例的时候，把我们认为必须绑定的属性强制填写进去。这里就用到Python当中的一个内置方法__init__方法，例如在Student类时，把name、score等属性绑上去:
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
注意：
（1）__init__方法的第一参数永远是self，表示创建的类实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。
（2）有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器会自己把实例变量传进去。
>>>student = Student("Hugh", 99)
>>>student.name
"Hugh"
>>>student.score
99
另外，这里self就是指类本身，self.name就是Student类的属性变量，是Student类所有。而name是外部传来的参数，不是Student类所自带的。故，self.name = name的意思就是把外部传来的参数name的值赋值给Student类自己的属性变量self.name。
（3）和普通数相比，在类中定义函数只有一点不同，就是第一参数永远是类的本身实例变量self，并且调用时，不用传递该参数。除此之外，类的方法(函数）和普通函数没啥区别，你既可以用默认参数、可变参数或者关键字参数（*args是可变参数，args接收的是一个tuple，**kw是关键字参数，kw接收的是一个dict）。
（4）既然Student类实例本身就拥有这些数据，那么要访问这些数据，就没必要从外面的函数去访问，而可以直接在Student类的内部定义访问数据的函数（方法），这样，就可以把”数据”封装起来。这些封装数据的函数是和Student类本身是关联起来的，称之为类的方法：
class Student(obiect):
def __init__(self, name, score):
self.name = name
self.score = score
def print_score(self):
print "%s: %s" % (self.name, self.score)
>>>student = Student("Hugh", 99)
>>>student.print_score
Hugh: 99
这样一来，我们从外部看Student类，就只需要知道，创建实例需要给出name和score。而如何打印，都是在Student类的内部定义的，这些数据和逻辑被封装起来了，调用很容易，但却不知道内部实现的细节。
如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线，在Python中，实例的变量名如果以开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问，所以，我们把Student类改一改：
class Student(object): def __init__(self, name, score):
self.__name = name
self.__score = score
def print_score(self):
print "%s: %s" %(self.__name,self.__score)
改完后，对于外部代码来说，没什么变动，但是已经无法从外部访问实例变量.__name和实例变量.__score了：
>>> student = Student('Hugh', 99)
>>> student.__name
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute '__name'
这样就确保了外部代码不能随意修改对象内部的状态，这样通过访问限制的保护，代码更加健壮。
但是如果外部代码要获取name和score怎么办？可以给Student类增加get_name和get_score这样的方法：
class Student(object):
... def get_name(self):
return self.__name def get_score(self):
return self.__score
如果又要允许外部代码修改score怎么办？可以给Student类增加set_score方法：
class Student(object):
... def set_score(self, score):
self.__score = score
需要注意的是，在Python中，变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用__name__、__score__这样的变量名。
有些时候，你会看到以一个下划线开头的实例变量名，比如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。
封装的另一个好处是可以随时给Student类增加新的方法，比如：get_grade:
class Student(object):
...
def get_grade(self):
if self.score >= 90:
return 'A'
elif self.score >= 60:
return 'B'
else:
return 'C'
同样的，get_grade方法可以直接在实例变量上调用，不需要知道内部实现细节：
>>> student.get_grade()
'A'
1.4、self的仔细用法
(1)、self代表类的实例，而非类。
class Test:
def ppr(self):
print(self)
print(self.__class__)t = Test()
t.ppr()
执行结果：
<__main__.Test object at 0x000000000284E080>
<class '__main__.Test'>
从上面的例子中可以很明显的看出，self代表的是类的实例。而self.__class__则指向类。
注意：把self换成this，结果也一样，但Python中最好用约定俗成的self。
（2）、self可以不写吗？
在Python解释器的内部，当我们调用t.ppr()时，实际上Python解释成Test.ppr(t)，也就是把self替换成了类的实例。
class Test:
def ppr():
print(self)t = Test()
t.ppr()
运行结果如下：
Traceback (most recent call last):
File "cl.py", line 6, in <module>
t.ppr()
TypeError: ppr() takes 0 positional arguments but 1 was given
运行时提醒错误如下：ppr在定义时没有参数，但是我们运行时强行传了一个参数。
由于上面解释过了t.ppr()等同于Test.ppr(t)，所以程序提醒我们多传了一个参数t。
这里实际上已经部分说明了self在定义时不可以省略。
当然，如果我们的定义和调用时均不传类实例是可以的，这就是类方法。
class Test:
def ppr():
print(__class__)Test.ppr()
运行结果：
<class '__main__.Test'>
（3）、在继承时，传入的是哪个实例，就是那个传入的实例，而不是指定义了self的类的实例。
class Parent:
def pprt(self):
print(self)class Child(Parent):
def cprt(self):
print(self)
c = Child()
c.cprt()
c.pprt()
p = Parent()
p.pprt()
运行结果：
<__main__.Child object at 0x0000000002A47080>
<__main__.Child object at 0x0000000002A47080>
<__main__.Parent object at 0x0000000002A47240>
解释：
运行c.cprt()时应该没有理解问题，指的是Child类的实例。
但是在运行c.pprt()时，等同于Child.pprt(c)，所以self指的依然是Child类的实例，由于self中没有定义pprt()方法，所以沿着继承树往上找，发现在父类Parent中定义了pprt()方法，所以就会成功调用。
（4）、在描述符类中，self指的是描述符类的实例
class Desc:
def __get__(self, ins, cls):
print('self in Desc: %s ' % self )
print(self, ins, cls)
class Test:
x = Desc()
def prt(self):
print('self in Test: %s' % self)
t = Test()
t.prt()
t.x
运行结果如下：
self in Test: <__main__.Test object at 0x0000000002A570B8>
self in Desc: <__main__.Desc object at 0x000000000283E208>
<__main__.Desc object at 0x000000000283E208> <__main__.Test object at 0x0000000002A570B8> <class '__main__.Test'>
这里主要的疑问应该在：Desc类中定义的self不是应该是调用它的实例t吗？怎么变成了Desc类的实例了呢？
因为这里调用的是t.x，也就是说是Test类的实例t的属性x，由于实例t中并没有定义属性x，所以找到了类属性x，而该属性是描述符属性，为Desc类的实例而已，所以此处并没有顶用Test的任何方法。
那么我们如果直接通过类来调用属性x也可以得到相同的结果。
下面是把t.x改为Test.x运行的结果。
self in Test: <__main__.Test object at 0x00000000022570B8>
self in Desc: <__main__.Desc object at 0x000000000223E208>
<__main__.Desc object at 0x000000000223E208> None <class '__main__.Test'>
2 在Python的string前面加上‘r’
这是为了告诉编译器这个string是个raw string，不要转意backslash ‘\’ 。 例如，\n 在raw string中，是两个字符，\和n， 而不会转意为换行符。由于正则表达式和 \ 会有冲突，因此，当一个字符串使用了正则表达式后，最好在前面加上’r’。
3 Python解析命令行读取参数
参考链接：
Python解析命令行读取参数 — argparse模块: https://www.cnblogs.com/arkenstone/p/6250782.html
4 python二维列表按列取元素
参考链接：
python 二维列表按列取元素: https://blog.csdn.net/xiaotao_1/article/details/80729458
Python-python中数组和列表读取一列的方法: https://www.cnblogs.com/laumians-notes/p/9069533.html
在python中，普通列表list和numpy数组array不一样，最大不同是：列表可以存放不同类型数据，包括int、float和str，甚至布尔型；而数组必须存放全部相同的数据类型，int或float。
在list中的数据类型保存的是数据的存放的地址，简单的说就是指针，并非数据，这样保存一个list就太麻烦了，例如list1=[1,2,3,4]需要4个指针和四个数据，增加了存储和消耗cpu，而array1=numpy.array([1,2,3,4])只需要存放四个数据，读取和计算更加方便，因此在做纯数字操作时，建议使用array。
也正因为列表可以存放不同类型的数据，因此列表中每个元素的大小可以相同，也可以不同，也就不支持一次性读取一列，即使是对于标准的二维数字列表：
>>> a=[[1,2,3],[4,5,6]]
>>> a[0] #取一行
[1, 2, 3]
>>> a[:,0] #尝试用数组的方法读取一列失败
TypeError: list indices must be integers or slices, not tuple
我们需要用列表解析的方法读取一列：
>>> b=[x[0] for x in a]
>>> print(b)
[1, 4]
而对于数组，可以直接读取：
>>> import numpy as np
>>> a=np.array([[1,2,3],[4,5,6]])
>>> a[:,0]
array([1, 4])
当然列表在处理混合数据时也有着独特的优势。
https://blog.csdn.net/mnasd/article/details/80398682
https://blog.csdn.net/agangz/article/details/80599120
http://www.runoob.com/python3/python3-string.html
https://zhidao.baidu.com/question/347902279.html
https://blog.csdn.net/lujiandong1/article/details/48808627
5 常见错误及解决
5.1 LookupError: unknown encoding: cp0
参考链接：https://stackoverflow.com/questions/17096631/lookuperror-unknown-encoding-cp0
解决办法：
Open Anaconda Prompt and type in: set PYTHONIOENCODING=UTF-8. Or, create an environment variable with name ‘PYTHONIOENCODING’ and value ‘UTF-8’.
Type spyder to start again.
我是通过在增加系统环境变量PYTHONIOENCODING，并将其值设为‘UTF-8’，得以解决问题。
5.2 UnicodeDecodeError: ‘ascii’ codec can’t decode
p.agent_info = str(agent_contact + ' ' + agent_telno).strip()
Basically, stop using str to convert from unicode to encoded text / bytes.
Instead, properly use .encode() to encode the string:
p.agent_info = u' '.join((agent_contact, agent_telno)).encode('utf-8').strip()
with open('ListingsPull-Amsterdam.csv', 'a') as file:
writer = csv.writer(file)
writer.writerow(rest_array)
The rest_array contains unicode strings. When you use csv.writer to write rows, you need to serialise bytes strings (you are on Python 2.7).
I suggest you to use “utf8” encoding:
with open('ListingsPull-Amsterdam.csv', mode='a') as fd:
writer = csv.writer(fd)
rest_array = [text.encode("utf8") for text in rest_array]
writer.writerow(rest_array)
6 python获取当前路径：https://www.cnblogs.com/strongYaYa/p/5860401.html
7 获取数据类型
例如：type(line)
参考链接：python 判断数据类型
8 Python 字符串大小写转换
https://www.runoob.com/python3/python3-upper-lower.html
以下代码演示了如何将字符串转换为大写字母，或者将字符串转为小写字母等：
str = "www.runoob.com"
print(str.upper()) # 把所有字符中的小写字母转换成大写字母
print(str.lower()) # 把所有字符中的大写字母转换成小写字母
print(str.capitalize()) # 把第一个字母转化为大写字母，其余小写
print(str.title()) # 把每个单词的第一个字母转化为大写，其余小写
执行以上代码输出结果为：
WWW.RUNOOB.COM
www.runoob.com
Www.runoob.com
Www.Runoob.Com
