可点进来看看的一些Python基础

1.
判断类型除了用 type(L) 
推荐使用 isinstance(L, list)


2.
将 x 十进制数转换为十六进制，八进制，二进制
hex(x) oct(x) bin(x)
表示为字符串


3.
x in y,x not in y 成员对象测试
x is y,x is not y 对象实体测试
1 < a < 3 可连续比较


4.
// 取整除 - 返回商的整数部分
9//2 输出结果 4 , 9.0//2.0 输出结果 4.0


5.
int(3.4), float(3) 强制类型转换


6.
Decimal 模块：小数模块
Decimal("0.01")
decimal.getcontext().prec = 4 设置全局精度为 4，小数点后 4 位


Fraction 模块：分数模块
Fraction(4, 6) 4/6
可接收字符串类型的参数 Fraction("0.25") 1/4


7.
set :无序，不重复元素集
s1.union(s2) 并集
s1.intersection(s2) 交集
s1.difference(s2) 差集
s1,stmmetric_difference(s2) 在 s1 或者 s2 中，但不会同时出现在二者中
s.add('x')  s.remove('X') 增加删除
s.update([x,x,x])  更新
x in s, x not in s 存在某值
{x**2 for x in [1,2,3,4]} {16,1,4,9} 集合解析，无序
{x for x in 'span'} {'a','p','s','n'} 集合解析，无序
set 是可变对象，即不存在 hash 值，不能作为字典的键值


8.
frozenset ：没有 add，remove 等方法
s = set([1,1,1])
x = set()
x.add(s)  error：set 是不可哈希类型
x.add(frozenset(s)) 


9.
布尔类型 bool：
type(bool) 返回 <class 'bool'>
isinstance(False, int) bool类型属于整形，所以返回True
True == 1 True
True is l False


10.
变量名通过引用，指向对象
L = [1], M = [1] , L is M False
L = M = [1] , L is M True
L = L + [2,3]  # L = [1,2,3] M = [1]
L += [2,3] # L = [1,2,3] M = [1,2,3]
普通 + 对此对象进行修改成新的对象
增强赋值 += 会找到对象的起始点进行修改


11.
字符串操作：s1 + s2, s1 * 3, s[i], s[i:j], len(s) 
字符串格式化表达式：'xxx %s yyy' % 'kind'
字符串格式化方法： 'x {1} {0} b'.format('c', 'v')
字符串迭代：
>>> s = "zhaoyi"
>>> for x in s: print (x)
... 
z
h
a
o
y
i
字符串列表解析：
>>> print [y * 2 for y in s]
['zz', 'hh', 'aa', 'oo', 'yy', 'ii']
字符串输出：
>>> print ','.join(['a','b','c'])
a,b,c


12.
部分内置函数 str 功能：
首字母大写：capitalize()
每个单词首字母大写：title()


13.
""" 编写多行字符串，并自己引入\n
temp = """ fdsfdsfs
dsada
 dsadsfs """
temp 是 fdsfdsfs\n dsada \n dsadsfs


14.
>>> S = [1,2,3,4,5,6,7,8,9,10,11,22]
>>> S[1:10:2]
[2, 4, 6, 8, 10]
>>> S[:-1]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
>>> S[1:]
[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 22]
>>> S[-1]
22
>>> S[0]
1
>>> 


15.
基于字典的格式化表达式
>>> print "%(n1)d---%(n2)s" % {"n1":11, "n2":"von"}
11---von


16.
a = [0,1,2,3,4,5,6,7]
del a[::2]
除去偶数项，a = [1,3,5,7]


17.
dict.update(dict_other) # 合并字典
dict.popitem() # 随机的一项键值对
字典键不一定非得是字符串，也可以为任何的不可变对象
字符串，整数，tuple都是不可变对象


18.
字典解析
>>> D = {k:8 for k in ['d','s']}
>>> D
{'s': 8, 'd': 8}
>>> z = {k:v for (k,v) in zip(['name', 'age'], ['tom', 12])}
>>> z
{'age': 12, 'name': 'tom'}


19.
元组和列表的唯一区别在于元组是不可变对象，列表是可变对象
不仅仅是长度不可变，元素也是不可变的


20.
元组的逗号和圆括号
>>> d = (12)
>>> d
12
>>> d = (12,)
>>> d
(12,)


21.
通常意义下的类型分类：
1.数字、序列、映射
2.可变类型和不可变类型


22.
常见赋值的形式
>>> sm = 'sm'
>>> sm
'sm'
>>> sm, sw = 'spam', 'swap'
>>> sm
'spam'
>>> sw
'swap'
>>> [sm, sw] = ['s', 'h']
>>> sm
's'
>>> sw
'h'
>>> a, b, c, d = 'abcd'
>>> a
'a'
>>> b
'b'
>>> c
'c'
>>> d
'd'
>>> sm = se = 'hh'
>>> sm
'hh'
>>> se
'hh'


Python3.x 有的序列解包形式
a, *b, c = 'sw'


23.
>>> 1 or 3 or 2
1
>>> 1 and 2 and 5
5
>>> 
and 或者 or 总是返回左边的对象或者右边的对象且具有短路求值的特性


24.
if/else 三元表达符
>>> x = 4
>>> a = 1 if x else 2
>>> a
1
>>> y = 0
>>> a = 1 if x else (2 if y else 3)
>>> a
1
>>> x = 0
>>> a = 1 if x else (2 if y else 3)
>>> a
3


也可用 and-or
>>> result = (a > 20 and "bigger than 20" or a > 10 and "bigger than 10")
>>> result
'bigger than 10'


25.
Python 的 while 语句或者 for 语句可以带else，当然也可以带 continue/break/pass
while a > 1:
lala
else:
hehe
for i in range(5):
lala
else:
hehe
else语句会在循环结束后执行


26.
>>> r = [a if a > 0 else 0 for a in [-1, 0, 1]]
>>> r
[0, 0, 1]
带判断条件的高级解析过程
>>> for a, b in zip(['A', 'A+'], ['B', 'B+']):
...  print (a + "vs" + b)
... 
AvsB
A+vsB+
>>> for index, data in enumerate(['a', 'b', 'c']):
...     print (index, data)
... 
(0, 'a')
(1, 'b')
(2, 'c')
enumerate 用处还是挺广泛的


27.
命名惯例
以单一下划线开头的变量名(_X)不会被from module import*等语句导入
前后有两个下划线的变量名(__X__)是系统定义的变量名，对解释器有特殊意义
以两个下划线开头但不以下划线结尾的变量名(__X)是类的本地(私有)变量


28.
手动迭代
>>> L = [1,2,3]
>>> i = iter(L)
>>> i.next()
1
>>> i.next()
2
>>> i.next()
3
>>> i.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration


29.
函数参数 * 和 ** 使用
>>> def f(a, *b, **c):
...     print (a,b,c)
... 
>>> f(1,2,3,x=4,y=5)
(1, (2, 3), {'y': 5, 'x': 4})


func(1, *(2, 3), **{'c':3, 'b':2})
等价于
func(1, 2, 3, b = 2, c = 3)


30.
了解 Lambda 的基本使用
>>> f1 = lambda x, y, z : x + y + z
>>> f1(1,2,3)
6
>>> f2 = lambda x = 1, y = 1 : x + y
>>> f2
<function <lambda> at 0x7fa2d68606e0>
>>> f2()
2
>>> list(map((lambda x: x+2), [1,2,3]))
[3, 4, 5]
>>> list(filter((lambda x: x>0), range(-4,5)))
[1, 2, 3, 4]
>>> reduce((lambda x, y: x + y), [1, 2, 3])
6


31.
生成器函数 yield
>>> def gen(N):
...     for i in range(N):
...             yield i ** 2
... 
>>> for i in gen(5):
...     print(i)
... 
0
1
4
9
16
>>> x = gen(2)
>>> next(x)
0
>>> next(x)
1
>>> next(x)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
如果说上面用的是 return，那么最终只会返回一个值，并不能达到展示过程的目的，而 yield 可以将状态挂起，恢复到那一时刻的状态


32.
生成器表达式 小括号进行列表解析
>>> g = (x ** 2 for x in range(3))
>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
生成器是单个迭代对象
>>> gen = (i for i in range(4))
>>> 2 in gen
True
>>> 3 in gen
True
>>> 1 in gen
False
生成器不保留迭代后的结果，检测2的时候，1已经跳过去不在了，同理2，3也不在了


33.
函数的默认值，我认为，可变的类型，参数在实例化是变化的，不可变的类型，在实例化是不可变的
>>> def foo(number=[]):
...     number.append(3)
...     print (number)
... 
>>> foo()
[3]
>>> foo()
[3, 3]
>>> foo()
[3, 3, 3]
改进
>>> def foo(number=None):
...     if number is None:
...             number = []
...     number.append(33)
...     print (number)
... 
>>> foo()
[33]
>>> foo()
[33]
>>> foo()
[33]
数字为参数，数字不可变
>>> def foo(count=1):
...     count += 1
...     print (count)
... 
>>> foo()
2
>>> foo()
2
>>> foo(4)
5
>>> foo(4)
5
>>> foo()
2


34.
Python中的多维数组
>>> lists = [0]*3
>>> lists
[0, 0, 0]
>>> lists = [[]] * 3
>>> lists[0].append(3)
>>> lists
[[3], [3], [3]]
>>> lists = [[] for i in range(3)]
>>> lists[0].append(3)
>>> lists[1].append(4)
>>> lists[2].append(5)
>>> lists
[[3], [4], [5]]
>>> lists = [[[] for j in range(4)] for i in range(3)]  # 3行4列


35.
import sys
sys.stdout # 是类文件对象，但是它们都只写，write()
sys.stdout.write("XXXX")


36.
包相对导入
from . import spam # 导入当前目录下的 spam 模块（错误：当前目录下的模块，直接导入即可）
from .spam import name # 导入当前目录下的 spam 模块的 name 属性（错误： 一定要加 . ，当前目录下的模块，不是直接导入）
from .. import spam # 导入当前目录的父目录下的 spam 


37.
Python 的类没有基于参数的函数重载
class temp:
  def test(self, string):
print (string)
  def test(self):
print ("hi")
后者 test 会覆盖前者


38.
class A(B):
  pass
a = A()
isinstance(a,B) # True ,A 是 B 的子类


39.
包装对象，委托 __getattr__ 钩子方法实现的，拦截对不存在属性的读取
class wrapper:
  def __init__(self, object):
self.wrapper = object
def __getattr(self, attrname):
print ('Trace:', attrname)
return getattr(self.wrapped, attrname)
getattr(X, N) 内置函数以变量名字字符串 N 从包装对象 X 中取出属性，类似于 X.__dict[N]
x = wrapper([1,2,3])
x.append(4)
"Trace: append" [1,2,3,4]
-----------------------------
x = wrapper({'a': 1, 'b': 2})
list(x.keys())
"Trace: keys" ['a', 'b']


40.
__attr 是类的伪私有属性
本面貌为： self._class.__attr = xxx 来改变


41.
动态语言灵活性
可给一个 class 的实例，继续添加属性和方法，使用 MethodType
c = Class()
c.new_method = MethodType(new_method, c) # 给实例加方法，类的其他实例不受影响


Class.new_method = MethodType(new_method, Student) # 给类绑定一个方法，所有实例共有


42.
函数装饰器
@staticmethod
def smeth(x):
  print x
等价于
def smeth(x):
  print x
smeth = staticmethod(smeth)
一般都为内置函数吧


43.
类修饰器
def dec(XXX):
pass


@dec
class C:
pass
等价于
class C:
pass
C = dec(C)


44.
class sss:
__slots__('1', '2')# 可列表可元组
限制只有1，2两个属性
只对当前类起作用，子类不起作用