一、基本语法

1、ipython命令技能实现python命令，也能实现部分linux命令。
2、python2不能识别文件里的中文，如果硬要识别，在头文件中加上 -- coding:utf-8 -- （python官方推荐这种方式）
3、输入一个数

1
high = input("请输入一个数")

4、输出一个数

1
2
3
4
5
age = 18
print("age的值为%d"%age)
name = "西芙"
print("name的值为%s"%name);
print("name的值是%s,年龄的值是%d"%(name,age))

4、if else语句

1
2
3
4
5
6
7
8
9
10
age = 19
if age>18:
    print("已经成年")
else
    print("未成年")
#input获取的所有数据都会当成字符串类型
#python 规定 str（）>int()
#所以如果 age  = input("一个值")
#要与int比较，需要把age换成int类型，即
#age_num = int(age)

5、python语言是弱类型的编程语言，及赋值的时候已经知道是什么类型
6、查看变量类型

1
type(a)

7、python的变量类型

1
2
3
4
5
6
·Numbers(数字)： int(有符号整型)，long（长整型[也可代表八进制和十六进制]），float（浮点型），complex（复数）
·布尔类型： True，False
·String（字符串）
·List（列表）
·Tuple（元组）
·Dictionary（字典）

8、关键字
查看关键字命令

1
2
import keyword #导入keyword包
keyword.kwlist

9、运算符

1
2
3
4
5
"s"*10
#输出'ssssssssss'

#幂
#**

10、is是地址相同的意思，在数值-5到256间，a与b地址相同，其余不同

11、深拷贝与浅拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#例1、浅拷贝
a = [11, 22, 33]
b = a #浅拷贝，地址拷贝，地址相同

#例2、深拷贝
import copy
c = copy.deepcopy(a) #开辟一个内存空间，拷贝内容

#例3、在数组中，深拷贝数组后，
a = [11,22,33]
b = [44,55,66]
c = [a, b]
d = copy.deepcopy[c]
#查看c，d的id，并不相同，深拷贝
#在a数组中添加[44],查看c[0],d[0]
a.append(44)
c[0]
[11,22,33,44]
d[0]
[11,22,33]
#说明深拷贝后，d另外拷贝了有关a、b的拷贝

#例4、有关指向a，b的拷贝
e = copy.copy(c)
a.append(55)
c[0]
e[0]
#所看到的结果都是[11,22,33,44,55]
id(c)
id(e)
#所看到的地址不同，所以他们是指向不同的地址但所指向数组的内容地址是相同的
#但如果是c = (a,b)，是元组的话，由于元组是不可变类型，e = copy.copy(c),他们所指向的地址是一样的
#所以使用copy模块的copy功能时候，它会根据当前拷贝的数据类型是可变类型还是不可变类型有不同的处理方式

12、私有化

1
2
3
4
5
6
7
8
9
10
class Test(object):
    def __init__(self):
        self.__num = 100
    def setNum(self, newNum):
        self.__num = newNum
    def getNum(self):
        return self.__num
t = Test()
t.__num = 200 #可以使用
print(t.__num)

升级版私有化 property使用

1
2
3
4
5
6
7
8
9
class Test(object):
    def __init__(self):
        self.__num = 100
    def setNum(self, newNum):
        self.__num = newNum
    def getNum(self):
        return self.__num
    num = property(getNum, setNum)#!!!!
#此时，可以用t.num = ?赋值 或者 t.num 取值，不用调用函数

装饰器使用

1
2
3
4
5
6
7
8
9
10
class Test(object):
    def __init__(self):
        self.__num = 100
    @property    
    def num(self):
        return self.__num
    @num.setter    
    def num(self, newNum):
        self.__num = newNum
#与上面的代码意思相同。理解一下吧~

1、xx:公有变量
2、x:单前置下划线，私有化属性或方法，from somemodule import * 禁止导入，类对象和子类可以访问
3、__x:双前置下划线，避免与子类中的属性命名冲突，无法在外部直接访问（名字重整所以访问不到）
4、x：双前后下划线，用户名字空间的魔法对象或属性。例如init,__不要自己发明这样的名字
5、xx_:单后置下划线，用于避免与python关键词的冲突

###但是私有属性实际上是可以访问，python把私有属性的名字由原来的_私有属性名 改成 _类名私有属性名，所以可以通过对象._类名__私有属性名可以获取值！！！

13、迭代器
迭代器 迭代器是访问集合元素的一种方式，迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，知道所有的元素被访问完结束。迭代器只能往前不会后退。
可迭代对象： 可直接作用于for循环的数据类型有以下几种： 一类是集合数据类型：如list、tuple、dict、set、str等 一类是generator，包括生成器和带yield的generator function。 可以直接作用于for循环的对象统称为可迭代对象：Iterable。

14、闭包：定义：函数里面有另外的函数，并且里面的函数用到了外面的函数的变量
闭包的应用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def test(number):
    print("--1--")
    def test_in(number2):
        print("--2--")
        print(number+number2)
    print("--3--")
    return test_in
    
ret = test(100)
print("-"*30)
ret(1)
ret(100)
ret(200)
#优点 简化了步骤

linux快捷键： %s/^/#/g 所有行前面加# 1,14/#//g 去掉1-14行的#
15、装饰器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def w1(func):
    def inner():
        print("----正在验证权限---")
        func()
    return inner
def f1():
    print("---f1---")
def f2():
    print("---f2---")

#innerFunc = w1(f1)
#innerFunc()

f1 = w1(f1)    #把w1（f1）赋值给f1，也就是说f1 = w1.inner，f1指向的就是inner这个函数
f1()   #调用后，执行的是inner，但由于之前传入f1的参数，所以输出结果为inner的输出结果+f1函数的输出结果

@w1 #与上面f1=w1(f1)意义相同，但只要python执行器执行到了这个代码，name就会自动的进行装饰，而不是等到调用的时候才装饰的  语法糖 @w1
def f1():
    print("---f1---")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#若有参数
def func(functionName):
    print("---func---1---")
    def func_in(*args, **kwargs):#如果没有定义参数，会导致调用的时候出现问题
        print("---func_in---1---")
        functionName(*args, **kwargs)#传入同样的参数
        print("---func_in---2---")      
    print("---func---2---")
    return func_in
@func
def test(a, b, c):
    print("---test-a=%d,b=%d,c=%d---"%(a,b,c))
    
@func
def test2(a, b, c, d):
    print("---test-a=%d,b=%d,c=%d,d=%d---"%(a,b,c,d))

test(11,22,33)
test2(44,55,66,77)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#通用装饰器
def func(functionName):
    def func_in(*args, **kwargs):
        print("---记录日志---")
        ret = functionName(*args, **kwargs)
        return ret
    return func_in

@func
def test():
    print("---test---")
    return "haha"

@func
def test2():
    print("---test2---")

@func
def test3(a):
    print("---test3---a=%d--"%a)
    
ret = test()
print("test return value is %s"%ret)

a = test2()
print("test2 return value is %s"%a)

test3(11)

16、作用域

#什么是命名空间
在某个范围内所能用到的作用域

17、类方法与静态方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#给类添加方法
import types #导入types包
class Person(object):
    def __init__(self, newName, newAge):
        self.name = newName
        self.age = newAge
    
    def eat(self):
        print("-----%s正在吃----"%self.name)

def run(self):
    print("-----%s正在跑----"%self.name)
    
p1 = Person("p1", 10)
p1.eat()
p1.run = types.MethodType(run, p1)
p1.run()

18、限制class实例添加的属性

1
2
3
4
5
6
class Person(object):
    __slots__ = ("name", "age")
p = Person()
p.name = "老王"
p.age = 20
p.score = 100 #会报错！！！

二、生成器、迭代器、装饰器、闭包

19、生成器

1
2
3
4
5
6
7
8
9
10
In [1]: a = [x*2 for x in range(10)]
In [2]: a
Out[2]: [0, 2, 4, 5, 6, 10, 12, 14, 16, 18]
#如果用[]，会生成数组，同时加载到内存中
#如果用括号（），输出的是一个地址，需要时才提取出
In [3]: b = (x*2 for x in range(10))
In [4]: b
Out[4]:  at 0x7fb057ff06d0>
In [5]:next(b)
Out[5]:0

20、a，b交换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def creatNum():
    print("----start----")
    a, b = 0, 1
    for i in range(5):
        print("----1----")
        yield b #python中有一个非常有用的语法叫做生成器，所利用到的关键字就是yield。有效利用生成器这个工具可以有效地节约系统资源，避免不必要的内存占用。当执行到这的时候，会做停顿。
        print("----2----")
        a, b = b, a+b
        print("----3----")
    print("----stop----")
#创建了一个生成器对象
a = creatNum()
#实现交换
a, b = 0, 1
a, b = b, a

21、斐波拉契数列

1
2
a,b = 0, 1
a,b = b, a+b #重复此步骤

22、类当做装饰器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#1
class Test(object):
    def __call__(self):
        print("---test---")        
t = Test()
t()
#out: ---test---

#2
class Test(object):
    def __init__(self, func):
        print('---初始化---')
        print('func name is %s'func.__name__)
        self.__func = func
    def __call__(self):
        print('---装饰器中的功能---')
        self.__func()

@Test  #相当于 t = Test(test)  
def test():
    print('---test---')

#out: ---初始化---
#out:func name is 'test'

test()
#out: ---装饰器中的功能
#out:---test---

23、元类

1
2
3
4
5
6
7
8
9
10
11
Test = type("Test", (), {})#相当于创建一个类
Test
#out:__main.Test

#创建一个拥有属性num=0的Person类
Person = type("Person",(),{"num":0})

#创建一个拥有方法printNum()的Test3类
def printNum(self):
    print("--num-%d--"%self.num)
Test3 = type("Test3",(),{"printNum":printNum})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#设置Foo类的属性变大写！！，通过metaclass设置
def upper_attr(future_class_name, future_class_parents, future_class_attr):
                #Foo                object                {bar:"bip"}
    #遍历属性字典，把不是__开头的属性名字变成大写
    newAttr = {}
    for name, value in future_class_attr.items():
        if not name.startswith("__"):
            newAttr[name.upper()] = value

    #调用type创建一个类
    return type(future_class_name,future_class_parents,newAttr)

class Foo(object,metaclass=upper_attr):
  #  __metaclass__ = upper_attr #设置Foo类的元类为upper_attr  python2
    bar = "bip"

print(hasattr(Foo, "bar"))
print(hasattr(Foo, "BAR"))
f = Foo()
print(f.BAR)

#out:False
#out:True
#out:bip

24、内建属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Itcast(object):
    def __init__(self,subject1):
        self.subject1 = subject1
        self.subject2 = 'cpp'
    #属性访问时拦截器，打log
    def __getattribute__(self,obj): #obj-->"subject1"
        if obj == 'subject1':
            print('log subject1')
            return 'redirect python'
        else:
            return object__getattribute__(self,obj)
    
    def show(self):
        print('this is Itcast')
        
s = Itcast("python")
print(s.subject1)
print(s.subject2)

三、内建方法

25、lambda之map

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#函数需要一个参数
map(lambda x: x*x, [1, 2,3])
#结果为：[1, 4, 9]

#函数需要两个参数
map(lambda x, y: x+y, [1, 2, 3], [4, 5, 6])
#结果为:[5,7,9]

def f1(x, y):
    return (x, y)
l1 = [0,1,2,3,4,5,6]
l2 = ['Sun', 'M', 'T', 'W', 'T', 'F', 'S']
l3 = map(f1, l1, l2)
print(list(l3))
结果为：[(0,'Sun'), (1,'M').....]

26、lambda之filter

1
2
3
4
5
fliter(lambda x : x%2, [1, 2 ,3, 4]) #如果为1，则输出
[1, 3]

filter(None, "she")
'she'

27、lambda之reduce

1
2
3
4
5
6
7
8
reduce(lambda x, y: x+y, [1,2,3,4])
10 #先把1赋值给x，2赋值给2，x+y后=3，把3赋值给x，数组中的3赋值给y，再累加，以此类推

reduce(lambda x, y:x+y, [1,2,3,4], 5)
15 #如果前面是数组，先把5赋值给x，再累加[1,,2,3,4]

reduce(lambda x, y: x+y, ['aa', 'bb', 'cc'], 'dd')
ddaabbcc

28、sort

1
2
3
4
5
6
7
8
9
a = [9,8,7,6,5,4,3,2,1]
a.sort()
a
#[1,2,3,4,5,6,7,8,9]

b = ['dd','cc','bb','aa']
b.sort()
b
#['aa','bb','cc','dd']

28、python的functools包中提供了一个叫wraps的装饰器来消除这样的副作用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import functools
def note(func):
    "note function"
    @functoolswraps(func)
    def wrapper():
        "wrapper function"
        print("note something")
        return func()
    return wrapper

@note
def test():
    "test function"
    print('I am test')

test()
print(test.__doc__)