python基础注意点（大杂烩）

个人博客 

github.io

github

1:在python中 None,  False, 空字符串"", 0, 空列表[], 空字典{}, 空元组()都相当于False 
与C不同的是，在python中是没有NULL的，取而代之的是None，它的含义是为空，但要注意和空列表与空字符串的区别，None的类型是Nonetype:再者，注意None与布尔类型的区别，布尔类型只包括两个：True和False（注意它的大小写）但python是把0，空字符串‘ ’和None都看作False，把其他数值和非空字符串都看作True

2:if x is not None`是最好的写法，清晰，不会出现错误，以后坚持使用这种写法。
使用if not x（x是否为空）这种写法的前提是：必须清楚x等于None,  False, 空字符串"", 0, 空列表[], 空字典{}, 空元组()时对你的判断没有影响才行。

3:python只有float 没有double

4:type(2/2)=float,type(2//2)=int整除

5:0b二进制 ob10=2 0o八进制 0x16进制, 
转化为二进制bin(10) bin(0xE), 转化为十进制int(0b11),转化为16进制 hex(888),转化为八进制oct(0o777),转化为bool bool(1)=True bool(0)=False,bool('asd')=True bool('')=False--(bool属于数字大分类),空值为False且None=False

6:print(r‘asddd’)字符串前加r表示是一个原始字符串,而不是一个普通字符串
  print(r’c:\nowwwwdd\noorssf’)= c:\nowwwwdd\noorssf而不会换行
  print(r’let’s go’)不行,引号必须成对出现
7:字符串运算1:+ 2:‘hello’*3出现3次(乘法) 3:’helloword’[1]取出e
  ‘hello world’[6:-1]=’worl’  ‘hello world’[6:-0]=’’ ‘hello world’[6:]=’world’
  ‘hello world’[-4:]=’orld’
8:type((1))=int type((1,))=tuple type((1)*2)=int
9:集合(不重复,无序)set类型 {1,2,3,4,5,6} -{3,4}={1,2,5,6}差集
      {1,2,3,4,5,6} & {3,4}={3,4}交集
      {1,2,3,4,5,6} | {3,4,7}={1,2,3,4,5,6,7} 
      set()空集
10:字符串格式化输出

print "My name is %s and weight is %d kg!" % ('Zara', 21) 
以上实例输出结果：
My name is Zara and weight is 21 kg!
11:a=1 b=a a=3 print(a)=3 print(b)=1 –------ a=[1,2,3,4,5] b=a a[0]=’1’ print(a)=print(b)=[‘1’,2,3,4,5] 前面为值类型(不可变还有 str tuple),后面为引用类型(可变 list set dict)
12:元祖不可改变,元祖中列表的值可以改变a=(1,2,[3,4]) a[2][1]=’4’ print(a)=(1,2,[3,’4’])
     
13:b=1 b+=b>=1  print(b)=2  ------b+=True ----b=b+True
14:字符串(列表 元祖比较都一样)比较大小 ‘a’>’b’=True比较ascii(ord(‘a’取出ascii) ‘abc’<‘abd’=True 每一位都比较ascii
15:0被认为是False 非0为True 空的字符串(tuple set list dict)被认为False 非空为True 
  [1] or []=[1]返回为True [1]也表示True
16:字典的成员运算 (in --not in)针对key(key中存在就返回True,没有就返回False)
     a={1,2,3} b={2,1,3} a==b 返回True (ps:集合无序所以相等) a is b 返回False (is,is not身份运算符比较地址)

     c=(1,2,3) d=(2,1,3) c==d 返回False (ps:元祖为有序的)

字典:1:不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
     2:键必须(不可变)，所以可以用(数字，字符串或元组)充当，所以用列表就不行
     3:元祖不可改变,元祖中列表的值可以改变a=(1,2,[3,4]) a[2][1]=’4’ print(a)=(1,2,[3,’4’])
17:类型判断 a=’hello’ isinstance(a,str) isinstance(a,(int,str,float))--是不是其中一种
18:& 按位与 |按位或 ^按位异或 ~按位取反 <<左移动 >>右移动
19:a or b and c=a or (a and c)先且运算再或运算 not>and>or级别相比其他最低
"a and b or c" 这是 Python 里经常用到的很方便的一个表达式，被用的很频繁。
intval > 1 and val1 or val2
如果 intval > 1 表达式为真返回 val1 否则返回 val2 ，但这只是其中一种逻辑。
(intval > 1 and val1) or val2
如上：如果 val1 是逻辑否，那么就会返回 val2 ，当你就是想返回一个逻辑否的值时，比如 (0,[],{},False,''),那么这个表达式就不能这么用了。
应该用：val1 if intval > 1 else val2
前段时间系统莫名其妙出现一个 bug ，查找半天发现很早以前不注意埋下了这个坑，耽误好多时间。

20:包模块导入 避免重复循环导入,导入某个包或模块会去执行一次其中的代码,导入包里面东西会自动执行__init__.py
21:两个变量接受函数返回的两个结果

22:函数的 必须参数 关键字参数 默认参数不能混淆赋值
23:类变量,实例变量 --类方法(@classmethod):不能访问实例变量--(java静态方法)--实例方法--
24:类数据成员可见性,公开,私有(不能外部访问) 加双划线__变量或方法变为私有 私有方法外部访问报错,私有变量外部访问不会报错(因为变成了一个新添加的变量) dict列表私有变量已经变为 -class—name
25:super(子类, self).父类方法(参数)子类调用父类
26:多类继承新式类搜索方式采用广度优先(从左到右搜索第一继承类,后再是第二继承类)
           经典类搜索方式是按照“从左至右，深度优先”的方式去查找属性
27:在python3中如果不指定继承哪个类，默认就会继承Object类，而继承了Object类的类就叫做新式类，
而在python2中如果不指定继承哪个类也不会默认去继承Object类，而没有继承Object类的类就叫做经典类

28:对象（实例）本身只有数据属性，但是python的class机制会将类的函数绑定到对象上，称为对象的方法，或者叫绑定方法，绑定方法唯一绑定一个对象，同一个类的方法绑定到不同的对象上，属于不同的方法，内存地址都不会一样 创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性：而类中有两种属性：数据属性和函数属性，
29:其中类的数据属性是共享给所有对象的，而类的函数属性是绑定到所有对象的。 
绑定到对象的方法,调用的时候会将对象参数自动传入, ===>方法上面什么也不加 
绑定到类的方法,调用的时候会将类作为参数自动传入, ===>方法上面加classmethod(调用classname.functionname)
30:首先，类的一般来说需要实例化后才能调用。但是使用了这前面两个装饰器，就可以不用实例化就可以直接调用类了。
非绑定方法不与类或对象绑定，类和对象都可以调用，但是没有自动传值(默认的参数传进函数)那么一说。===>staticmethod
staticmethod与classmethod的区别：前者是非绑定方法,后者是绑定到类的方法  
{
1、当一个函数逻辑上属于一个类又不依赖与类的属性的时候，可以使用 @staticmethod。
2、使用 @staticmethod 可以避免每次使用的时都会创建一个对象的开销。
3、@staticmethod 可以使用类和类的实例调用。但是不依赖于类和类的实例的状态。
}
31寻找属性和方法的顺序问题：先从对象自己的命名空间中找，然后在自己的类中，最后在从父类当中去找 
在类内部定义的属性属于类本身的,由操作系统只分配一块内存空间,大家公用这一块内存空间
子类不重写 __init__，实例化子类时，会自动调用父类定义的 __init__。
如果重写了__init__ 时，实例化子类，就不会调用父类已经定义的 __init__
如果重写了__init__ 时，要继承父类的构造方法，可以使用 super 关键字：
super(子类，self).__init__(参数1，参数2，.…)
还有一种经典写法：
父类名称.__init__(self,参数1，参数2，...)
将另外一个对象作为自己的属性成员（自己的一个属性来自于另外一个对象），这就是组合 

32:   if __name__=="__main__":
第一是直接作为脚本执行，第二是import到其他的python脚本中被调用（模块重用）执行。因此if __name__ == 'main': 的作用就是控制这两种情况执行代码的过程，在if __name__ == 'main': 下的代码只有在第一种情况下（即文件作为脚本直接执行）才会被执行，而import到其他脚本中是不会被执行的。
每个python模块（python文件，也就是此处的test.py和import_test.py）都包含内置的变量__name__,当运行模块被执行的时候，__name__等于文件名（包含了后缀.py）；如果import到其他模块中，则__name__等于模块名称（不包含后缀.py）。而“__main__”等于当前执行文件的名称（包含了后缀.py）。进而当模块被直接执行时，__name__ == 'main'结果为真。
29:  用单下划线(_one_underline)开头表示方法不是API的一部分，不要直接访问（虽然语法上访问也没有什么问题）。
使用双下划线开头(__two_underlines)开头表示子类不能覆写该方法。除非你真的知道你在干什么，否则不要使用这种方式。
当你想让自己定义的对象也可以像Python内置的对象一样使用Python内置的一些函数或操作符（比如len、add、+、-、==等）时，你可以定义该类方法

写在最后-django:从上面外键(ForeignKey)和一对一(OneToOneField)的参数中可以看出,都有on_delete参数,而 django 升级到2.0之后,表与表之间关联的时候,必须要写on_delete参数,否则会报异常:因为多对多(ManyToManyField)没有 on_delete 参数,所以略过不提.
on_delete=None,               # 删除关联表中的数据时,当前表与其关联的field的行为
on_delete=models.CASCADE,     # 删除关联数据,与之关联也删除
on_delete=models.DO_NOTHING,  # 删除关联数据,什么也不做
on_delete=models.PROTECT,     # 删除关联数据,引发错误ProtectedError
# models.ForeignKey('关联表', on_delete=models.SET_NULL, blank=True, null=True)
on_delete=models.SET_NULL,    # 删除关联数据,与之关联的值设置为null（前提FK字段需要设置为可空,一对一同理）
# models.ForeignKey('关联表', on_delete=models.SET_DEFAULT, default='默认值')
on_delete=models.SET_DEFAULT, # 删除关联数据,与之关联的值设置为默认值（前提FK字段需要设置默认值,一对一同理）
on_delete=models.SET,         # 删除关联数据,
 a. 与之关联的值设置为指定值,设置：models.SET(值)
 b. 与之关联的值设置为可执行对象的返回值,设置：models.SET(可执行对象)