IPython

简介

一个python的交互式shell，比默认的python shell要好用的多

特性

1. 自动补全代码（按下tab）
2. 自动缩进
3. 支持bash shell命令
4. 内置了很多有用的功能和函数
5. 使用%run命令运行脚本
6. 使用%timeit命令快速测量时间
7. 使用%pdb命令快速debug
8. 使用pylab进行交互计算
9. 使用IPython Notebook

   安装

   首先确保已经安装了python，在cmd键入命令“python”查看是否已安装；然后输入如下命令进行ipython安装

   pip install ipython

使用

进入ipython图形化界面

键入命令：

ipython qtconsole

不过现在官方已经不建议使用该命令了，推荐如下命令进入jupyter图形化界面：

jupyter qtconsole

对象内省

通过在变量的前面或者后面加上问号？，就可以将该对象的一些通用信息显示出来

同样也可以查看方法的一些通用信息

查看历史命令

通过键入如下命令即可查看当前console中输入的历史命令

hist # 或者 history

通过加入 -n 参数可以显示出输入的序号：

hist -n

%run运行脚本

%run 路径 + python文件名

%timeit快速测量代码运行时间

%timeit [x * x for x in range(1000)]

%pdb激活ipython调试器

使用notebook

通过键入命令会打开ipython notebook，不过官方已经自动转向 jupyter notebook了：

ipython notebook # 与命令 jupyter notebook 执行结果一样

在notebook中通过如下两个操作都可以运行脚本：

shift + enter：执行当前输入框命令，同时会新建一个新的输入框，并将光标移动到新的输入框

ctrl + enter：执行当前输入框命令，不会新建一个新的输入框

面向对象前置学习

注释

单行注释

通过#号来编写单行注释

这是一个单行注释

多行注释

通过三个引号进行包裹

‘’’ 慈母手中线，游子身上衣 临行密密缝，意恐迟迟归 ‘’’

也可以通过三个双引号进行包裹

“”” 锄禾日当午，汗滴禾下土 谁知盘中餐，粒粒皆辛苦 “””

数组

一维数组切片

切片格式：arr[startIdx: endIdx]

考虑如下场景：

1. startIdx > endIdx：此时取值：[startIdx, endIdx-1]
2. startIdx < endIdx：此时返回空数组

如果索引值小于0，则表示从最后的索引位置开始计算，其中-1表示最后一个元素

import numpy as np
if __name__ == "__main__":
    seq_number = np.array(
        [112., 118., 132., 129., 121., 135., 148., 148., 136., 119., 104.,
         118., 115., 126., 141., 135., 125., 149., 170., 170., 158., 133.,
         114., 140., 145., 150., 178., 163., 172., 178., 199., 199., 184.,
         162., 146., 166., 171., 180., 193., 181., 183., 218., 230., 242.,
         209., 191., 172., 194., 196., 196., 236., 235., 229., 243., 264.,
         272., 237., 211., 180., 201., 204., 188., 235., 227., 234., 264.,
         302., 293., 259., 229., 203., 229., 242., 233., 267., 269., 270.,
         315., 364., 347., 312., 274., 237., 278., 284., 277., 317., 313.,
         318., 374., 413., 405., 355., 306., 271., 306., 315., 301., 356.,
         348., 355., 422., 465., 467., 404., 347., 305., 336., 340., 318.,
         362., 348., 363., 435., 491., 505., 404., 359., 310., 337., 360.,
         342., 406., 396., 420., 472., 548., 559., 463., 407., 362., 405.,
         417., 391., 419., 461., 472., 535., 622., 606., 508., 461., 390.,
         432.], dtype=np.float32)
    print(seq_number[0: 5])
    print(seq_number[1:0])
    print(seq_number[-5: -1])
    print(seq_number[-1: -5])

打印结果：

[112. 118. 132. 129. 121.]
[]
[606. 508. 461. 390.]
[]

二维数组切片

切片格式：arr[rowStart:rowEnd, colStart:colEnd]

其中：rowStart和rowEnd用于指定行取值范围，colStart和colEnd用于指定列取值范围

import numpy as np
if __name__ == "__main__":
    seq_number = np.array(
        [112., 118., 132., 129., 121., 135., 148., 148., 136., 119., 104.,
         118., 115., 126., 141., 135., 125., 149., 170., 170., 158., 133.,
         114., 140., 145., 150., 178., 163., 172., 178., 199., 199., 184.,
         162., 146., 166., 171., 180., 193., 181., 183., 218., 230., 242.,
         209., 191., 172., 194., 196., 196., 236., 235., 229., 243., 264.,
         272., 237., 211., 180., 201., 204., 188., 235., 227., 234., 264.,
         302., 293., 259., 229., 203., 229., 242., 233., 267., 269., 270.,
         315., 364., 347., 312., 274., 237., 278., 284., 277., 317., 313.,
         318., 374., 413., 405., 355., 306., 271., 306., 315., 301., 356.,
         348., 355., 422., 465., 467., 404., 347., 305., 336., 340., 318.,
         362., 348., 363., 435., 491., 505., 404., 359., 310., 337., 360.,
         342., 406., 396., 420., 472., 548., 559., 463., 407., 362., 405.,
         417., 391., 419., 461., 472., 535., 622., 606., 508., 461., 390.,
         432.], dtype=np.float32)
    seq_number = seq_number[:, np.newaxis]
    seq_year = np.arange(12)
    seq_month = np.arange(12)
    seq_year_month = np.transpose(
        [np.repeat(seq_year, len(seq_month)),
         np.tile(seq_month, len(seq_year))],
    )  # Cartesian Product
    seq = np.concatenate((seq_number, seq_year_month), axis=1)
    print("--------------origin data-------------")
    print(seq)
    print("---------------split data--------------")
    print(seq[0:3, 0:2])
    print("--------------split data2----------------")
    print(seq[0:3, 0])

打印结果：

--------------origin data-------------
[[112.   0.   0.]
 [118.   0.   1.]
 [132.   0.   2.]
 [129.   0.   3.]
 [121.   0.   4.]
 [135.   0.   5.]
 [148.   0.   6.]
 [148.   0.   7.]
 [136.   0.   8.]
 [119.   0.   9.]
 [104.   0.  10.]
 [118.   0.  11.]
 [115.   1.   0.]
 [126.   1.   1.]
 [141.   1.   2.]
 [135.   1.   3.]
 [125.   1.   4.]
 [149.   1.   5.]
 [170.   1.   6.]
 [170.   1.   7.]
 [158.   1.   8.]
 [133.   1.   9.]
 [114.   1.  10.]
 [140.   1.  11.]
 [145.   2.   0.]
 [150.   2.   1.]
 [178.   2.   2.]
 [163.   2.   3.]
 [172.   2.   4.]
 [178.   2.   5.]
 [199.   2.   6.]
 [199.   2.   7.]
 [184.   2.   8.]
 [162.   2.   9.]
 [146.   2.  10.]
 [166.   2.  11.]
 [171.   3.   0.]
 [180.   3.   1.]
 [193.   3.   2.]
 [181.   3.   3.]
 [183.   3.   4.]
 [218.   3.   5.]
 [230.   3.   6.]
 [242.   3.   7.]
 [209.   3.   8.]
 [191.   3.   9.]
 [172.   3.  10.]
 [194.   3.  11.]
 [196.   4.   0.]
 [196.   4.   1.]
 [236.   4.   2.]
 [235.   4.   3.]
 [229.   4.   4.]
 [243.   4.   5.]
 [264.   4.   6.]
 [272.   4.   7.]
 [237.   4.   8.]
 [211.   4.   9.]
 [180.   4.  10.]
 [201.   4.  11.]
 [204.   5.   0.]
 [188.   5.   1.]
 [235.   5.   2.]
 [227.   5.   3.]
 [234.   5.   4.]
 [264.   5.   5.]
 [302.   5.   6.]
 [293.   5.   7.]
 [259.   5.   8.]
 [229.   5.   9.]
 [203.   5.  10.]
 [229.   5.  11.]
 [242.   6.   0.]
 [233.   6.   1.]
 [267.   6.   2.]
 [269.   6.   3.]
 [270.   6.   4.]
 [315.   6.   5.]
 [364.   6.   6.]
 [347.   6.   7.]
 [312.   6.   8.]
 [274.   6.   9.]
 [237.   6.  10.]
 [278.   6.  11.]
 [284.   7.   0.]
 [277.   7.   1.]
 [317.   7.   2.]
 [313.   7.   3.]
 [318.   7.   4.]
 [374.   7.   5.]
 [413.   7.   6.]
 [405.   7.   7.]
 [355.   7.   8.]
 [306.   7.   9.]
 [271.   7.  10.]
 [306.   7.  11.]
 [315.   8.   0.]
 [301.   8.   1.]
 [356.   8.   2.]
 [348.   8.   3.]
 [355.   8.   4.]
 [422.   8.   5.]
 [465.   8.   6.]
 [467.   8.   7.]
 [404.   8.   8.]
 [347.   8.   9.]
 [305.   8.  10.]
 [336.   8.  11.]
 [340.   9.   0.]
 [318.   9.   1.]
 [362.   9.   2.]
 [348.   9.   3.]
 [363.   9.   4.]
 [435.   9.   5.]
 [491.   9.   6.]
 [505.   9.   7.]
 [404.   9.   8.]
 [359.   9.   9.]
 [310.   9.  10.]
 [337.   9.  11.]
 [360.  10.   0.]
 [342.  10.   1.]
 [406.  10.   2.]
 [396.  10.   3.]
 [420.  10.   4.]
 [472.  10.   5.]
 [548.  10.   6.]
 [559.  10.   7.]
 [463.  10.   8.]
 [407.  10.   9.]
 [362.  10.  10.]
 [405.  10.  11.]
 [417.  11.   0.]
 [391.  11.   1.]
 [419.  11.   2.]
 [461.  11.   3.]
 [472.  11.   4.]
 [535.  11.   5.]
 [622.  11.   6.]
 [606.  11.   7.]
 [508.  11.   8.]
 [461.  11.   9.]
 [390.  11.  10.]
 [432.  11.  11.]]
---------------split data--------------
[[112.   0.]
 [118.   0.]
 [132.   0.]]
--------------split data2----------------
[112. 118. 132.]

python常用函数

用户输入函数

input函数用于接收用户输入，格式为：

该方法会返回一个String类型

input(“输入提示信息：”)

输出函数

print函数用于输出到终端，格式为：

print(“welcome to China”);

同时可以对输出的内容进行格式化，常用的有三种：

%s 字符串 %d 整数 %f 浮点数

常用类型转换函数

流程控制语句

if - elif -else

age = int(input("请输入您的年龄："))
if age < 10:
    print("小屁孩")
elif age < 16:
    print("未成年人")
elif age < 30:
    print("中年人")
else:
    print("这是啥")

while

count = int(input("请输入循环次数："))
while  count> 0:
    print("循环剩余%d次"%(count))
    count = count-1

do-while

与while类似，不过是先执行，后判断循环条件

自定义函数

定义

函数的定义格式：

def fun_name(arg1, arg2, …): fun_body return var1, var2,…

调用

函数的调用:

fun_name(my_arg1, my_arg2,…)

函数缺省参数

即定义函数参数的同时，为其指定一个默认值，具有默认值的参数就叫做缺省参数

def fun(name, age, type=1):
    ...
fun("JreamY", 20, type=2);
fun("wangzhun", 20);

函数多值参数

在定义函数的时候可能无法确定需要传递的参数个数，这时候可以将参数定义为多值参数

定义格式分为两种：

1. 参数名前增加一个*，表示接收元组
2. 参数名前增加一个**，表示接受字典

一般习惯性以下列两个名字对应命名：

1. *args
2. **kwargs

示例：

def fun(name, *args, **kwargs):
    print(name)
    print(args)
    print(kwargs)
    return
fun("JreamY", 2, 3, 4, 5, age=20, gender="man")

函数返回值

一个函数可以返回多个值，默认是元组的形式

def fun():
    name = "JreamY"
    age = 20
    return name, age
result = fun()
# 将会输出tuple
print(type(result))

高级变量

基础变量回顾

列表

概念

python中定义最频繁的数据类型，在其他语言中通常叫做数组

定义

定义格式：

list_name = [ele1, ele2, …]

列表的索引从0开始计数

常用操作

取值：

list_name[ele_idx]

在ipython中输入下列命令然后按下tab键就可以查看操作列表，即其可以使用的方法列表：

list_name. # 然后按下tab键

遍历列表

遍历格式：

for ele in list_name: for_body

元组

概念

元组和列表类似，不同之处在于元组里面的元素不能修改

定义

tuple_name = {ele1, ele2, …}

当创建只包含一个元素的元组时，需要在元素后面添加逗号

tuple_name = {ele1,}

常用操作

遍历元组

for ele in tuple: for_body

元组和列表转换

list转换为tuple

list(tuple_name)

tuple转换为list

tuple(list_name)

字典

概念

除列表以外Python中最灵活的数据类型，类似于java中的Map数据类型
字典里面的元素是无序的
字典里面的key必须是唯一的，且只能使用字符串、数字或者元组作为键值

定义

dict = {key1: val1, key2: val2}

常用操作

遍历字典

for key in dict: key = k value = dict[k] for_body

字符串

定义

一对单引号或者一对双引号即可定义，建议使用双引号：

str1 = ‘welcome’ str2 = “welcome”

常用操作

公共方法

python对高级变量提供的内置函数：

切片

支持的数据类型：字符串、列表、元组
切片格式：

data[start:end:step] # 最终结果：[start, end) step默认步长为1

运算符

完整的for循环语法

for var in collection:
    for_body
else:
    # 如果不是因为执行了break而退出的循环，就会执行这块代码，否则不会执行
    else_body

局部变量和全局变量

局部变量

在函数内部定义的变量

全局变量

在函数外部定义的变量

在函数内部中获取/修改全局变量

通过global关键字引用变量，表示该变量使用的是全局变量

num = "JreamY"
def fun():
    global num
    num = "wangzhun"
fun()

面向对象学习

dir内置函数

用于获取对象的所有属性和方法

使用格式：

dir(object)

类

定义

类设计三要素：

1. 类名：大驼峰命名法
2. 属性：类具有的特征
3. 方法：类具有的行为

定义格式：

class class_name：

def fun_name(self, arg1, arg2): ‘’’ function body ‘’’

类中定义方法的格式与函数大致一样，区别在于第一个参数必须是self，代表的是当前调用对象

创建对象

创建语法：

object_name = class_name()

创建对象时，会自动执行以下操作：

1. 为对象在内存中分配空间 - 创建对象 (new)
2. 为对象的属性设置初始值 - 初始化方法（init）

   对象创建方法 new

   通过重写该方法用于实现单例模式生成类对象

class MyCls(object):
    instance = None
    def __new__(cls, *args, **kwargs):
        if(instance is None) {
            instance = super().__new__(cls)
        }
        return instance
    def __init__(self):
        ''' init method body '''

初始化方法 init

对象的内置方法，专门用于定义一个类具有哪些属性

格式：

def init(self): ‘’’ do something init object’’’

在初始化方法中定义属性:

class MyCls:
    def __init__(self):
        self.name = "JreamY"
''' 创建对象 '''
cls = MyCls()
class MyCls2:
    def __init__(self, name):
        self.name = name
        # 也可以暂时设置值为空值
        self.age = None
''' 创建对象 '''
cls2 = MyCls2("JreamY")

对象销毁前置方法del

当对象从内存中销毁之前，会自动调用该方法

格式：

def del(self): ‘’’ do something ‘’’

打印对象信息方法str

类似于Java中的toString方法

格式：

def str(self): ‘’’ do something ‘’’

可调用对象生成方法call

存在call方法的对象被称为可调用对象，可以直接通过对象名称进行调用，如下：

class Cls(object):
    def __call__(self, name):
        print("my name is {}, print by call method".format(name))
cls = Cls()
cls("JreamY")

数组对象生成方法getitem

如果一个类中定义了getitem()方法，那么该类的实例对象cls就可以通过cls[idx]的形式进行取值，获取的结果与调用cls.getitem(idx)方法相同

getiem()方法使用示例:

class Cls(object):
    # 定义一个列表数据
    arrs = []
    def __init__(self, arrs):
        self.arrs = arrs
    def __getitem__(self, index):
        return self.arrs[index]
myarrs = ['wangzhun', 'zhunwang']
cls = Cls(myarrs)
print('one -> {}, two -> {}'.format(cls[0], cls[1]))

类说明信息打印属性doc

在类中编写的说明信息，可以通过该内置方法进行输出，如下：

class Cls(object):
    '''
    print some thing about Cls info
    '''
cls = Cls()
print(cls.__doc__)

None属性值

当不确定属性值，同时又想定义类具有该属性时，可以通过如下格式定义：

class MyCls2:

def __init__(self, name):
    self.name = name
    # 也可以暂时设置值为空值
    self.age = None

对属性值进行None校验，可以通过 == 或 is，python官方建议使用is：

cls.age is None # 返回True 或者False

属性、方法私有化

概念

某些属性或方法只希望在对象的内部被使用，而不希望被外部访问到

定义

通过在属性或者方法前面增加两个下划线，即表示定义的是私有属性或私有方法

class MyCls:

    def __init__(self, name):
        self.__name = name

    def __primethod(self):
        print("it is a private method")

伪私有化

在Python中，其实并没有将属性或者方法真正私有化，而是将带有__前缀的属性或方法进行了重命名

重命名的方式：在名称前面加上：_类名，最终仍然可以通过如下方式进行访问：

cls = MyCls()

cls._MyCls__primethod()

类属性和类方法定义

与实例属性通过self进行初始化不同，类属性通过类名进行初始化，格式为：

class MyCls:

    # 类属性定义
    count = 0

    def __init__(self, o_name):
        self.name = o_name
        MyCls.count += 1

    # 类方法定义 ，必须使用@classmethod修饰，同时方法的第一个参数为cls
    @classmethod
    def c_method_name(cls):
        ''' c_method body '''

继承

在Python中，一个类可以同时继承多个父类

需要注意的是：不同的父类之间不能出现同名的方法和属性

语法

class SubClass(SuperClass1， SuperClass2， SuperClass3): ‘’’ class body ‘’’

方法重写

同Java

子类方法中调用父类方法

通过super关键字进行调用

super().super_class_method()

也可以通过父类名进行调用，不过不推荐：

super_class_name.super_class_method()

mro属性

当一个类继承多个父类时，可通过该类属性来查看该类对应的对象的属性/方法查找顺序（从左往右）

示例：

class A:
    def fun1():
        pass

class B:
    def fun2():
        pass

class C(A, B):
    def fun():
        pass

print(C.__mro__)

异常

异常捕获语句块：try-except-else-finally

格式：

try: ‘’’ body ‘’’ except exp_type1: ‘’’ do somthing if accur exception ‘’’ except (exp_type2, exp_type3): ‘’’ do something if accur exception ‘’’ ‘’’ 捕获未知异常 ‘’’ except Exception as result: ‘’’ do something if accur exception ‘’’ ‘’’ 如果最终没有抛出异常，则会执行else里面的代码部分 ‘’’ else: ‘’’ do something if not accur exception ‘’’ ‘’’ 不管最终有没有抛出异常，都会执行finally里面的代码部分 ‘’’ finally: ‘’’ do something whether accur exception or not ‘’’

主动抛出异常

def num_check(num):
    if(num < 0) {
        raise Exception("数值必须大于等于0")
    }
    print("Pass")

文件

基本操作

操作示例

file = open("filename.txt")

text = file.read()

print(text)

file.close()

打开文件的方式

file = open(“文件路径”, “访问方式”)

访问方式有如下六种：

readline使用

def readFile(filepath):

    file = open(filepath, r)

    while True:

        text = file.readline()

        if not text:
            break

        # 每一行的末尾本身就有换行符了，所以end可以设置为""不需要默认的"\n"了
        print(text, end="")