Jupyter Notebook->File->New Notebook ->python[default]
完整版->有道云笔记

一、变量与基本数据类型

1.变量

每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。每个变量在使用前都必须赋值，赋值号是“=”

int_var = 3
float_var = 3.1415926
str_var = "Hello"

print(int_var, float_var, str_var)
print(int_var, type(int_var))
print(float_var, type(float_var))
print(str_var, type(str_var))

输出结果：
3 3.1415926 Hello
3 <class 'int'>
3.1415926 <class 'float'>
Hello <class 'str'>
Jupyter Notebook->File->New Notebook ->python[default]

2.Python的标识符

在Python里，标识符由字母、数字、下划线组成，所有标识符可以包括英文、数字以及下划线_，但不能以数字开头

x_6 = 5
#错误标识符
6_x = 5   

  File "<ipython-input-19-430b4ee4710a>", line 2
    6_x = 5
      ^
SyntaxError: invalid syntax

Python3直接支持中文符号，包括标识符名

变量1 = 8
print(变量1)
# 8

3.保留字

保留字不能用作常数或变数，或任何其他标识符名称。所有Python的关键字只包含小写字母。

    import keyword
    keyword.kwlist
    # 输出结果：['False','None','True','and','as', 'assert','break','class','continue','def','del',
    # 'elif','else','except', 'finally', 'for', 'from', 'global', 'if','import', 'in',
    # 'is','lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while',
    # 'with', 'yield']

4.数字数据类型

数字数据类型用于存储数值，Python支持不同的数字类型：

• int(有符号整型)，缺省十进制，还可以表示2、8、16进制；Python不再保留长整型，统一为int；
• float(浮点型)，可以用科学计数法表示；

    var1 = 1e-5; var2 = 6.7e16; var3 = -1.8
    print(var1, var2, var3)
    # 1e-05 6.7e+16 -1.8

• complex(复数)，复数由实数部分和虚数部分构成，可以用a+bj后者complex(a,b)表示，复数的实部a和虚部b都是浮点型。

    var1 = 3+5.3j; var2 = complex(3.4e5,7.8)
    print(var1, type(var1), var2, type(var2))
   # (3+5.3j) <class 'complex'> (340000+7.8j) <class 'complex'>

• 0b, 0o, 0x分别代表2进制、8进制和16进制数

    # 多条语句可以放在一行，中间用分号隔开
    var1 = 0b10; var2 = 0o10; var3 = 0x10
    print(var1,var2,var3)
    # 2 8 16

• Python直接支持很长的整数

    var1 = 12334543544253421243524131
    print (var1, type(var1))
    # 12334543544253421243524131 <class 'int'>

• 布尔类型，bool值：True and False

5.注释

• 单行注释用 "#"
• 多行注释用 '''或者"""

    print("1")
    '''
    print("注释")
    print("注释")
    '''
    print("1")
    
    # 1
    # 1

二、基本运算

1.算术运算

以下假设变量：x=10, y=3

2.比较运算

比较运算符，包括>, <, ==, >=, <=, !=，<>，返回为True或False

3.赋值运算

4.逻辑运算

逻辑运算符包括and or not，非0的值视作True，False的值就是0，True的值就是1.

三、字符串

• 字符串可以用双引号”，也可以用单引号'。
• 转义字符是反斜杠“\”，若不想让反斜杠发生转义，可以在字符串前添加一个r,表示原始字符串。
• 多行字符串可通过三个连续的单引号或是双引号来进行标示。
• 使用+进行字符串链接

    "Hello" + " World!"
    # 'Hello World!'

• 使用*进行字符串链接

    "Bye" * 2
    # 'ByeBye'

四、List列表

1.写法

List是Python中使用最频繁的数据类型，写在方括号[]之间、元素之间用逗号分隔开

2.元素类型

列表中的元素类型可以不相同，它支持数字，字符串甚至可以包含列表(嵌套)

    list1 = [1,2,3,4,5,6,"hello python",[7,8,9,10]]
    print(list1)
    # [1, 2, 3, 4, 5, 6, 'hello python', [7, 8, 9, 10]]

3.列表元素访问

可用于通过索引(下标)和截取(切片)，列表被截取后返回一个包含所需元素的新列表。列表下标从0开始，-1表示倒数第1个。下标访问不要越界。

• 单个列表元素访问语法格式为：列表名[下标]

    list1[0]
    # 1
    list1[-1]
    # [7,8,9,10]

• 列表截取语法格式为：列表名[头下标:尾下标]，返回包含所需内容的新列表，结果不包含尾下标元素。

    list1[6:8]
    # ['hello python', [7, 8, 9, 10]]
    # 切片步长
    list1[::2]
    # [1, 3, 5, 'hello python']
    list1[1::2]
    # [2, 4, 6, [7, 8, 9, 10]]

• 访问嵌套列表元素：层层深入

    print(list1[-1][1:])
    # [8, 9, 10]
    

• 字符串是一种特殊列表，可以按列表元素的访问方法来访问字符串中的元素

    str1 = "hello, hangzhou!"
    print(str1[2:5])
    # llo

五、Tuple元组

1.写法

元组写在小括号()里，元素之间用逗号隔开

2.元素类型

元组中元素的类型可以不相同，和列表类似，也支持嵌套

    tuple1 = (1,2,3,4,5,6,"hello python",[8,9,10],(11,12))
    print(tuple1, type(tuple1))
    # (1, 2, 3, 4, 5, 6, 'hello python', [8, 9, 10], (11, 12)) <class 'tuple'>

3.访问方式

元组的元素访问和截取方式与列表相同，通过下标来操作

    print(tuple1[0])
    print(tuple1[-1])
    print(tuple1[6:-1])
    print(tuple1[-1][-1])
    #        1
    #        (11, 12)
    #        ('hello python', [8, 9, 10])
    #        12

4.与列表区别

元组一旦定义好就不能修改，是只读的，而列表可修改

    #元组
    tuple1[1] = 7
    # TypeError: 'tuple' object does not support item assignment
    
    #列表
    list1 = [1,2,3,4,5,6,7]
    list1[2] = 1000
    print(list1)
    # [1, 2, 1000, 4, 5, 6, 7]

六、Set(集合)

集合(set)是一个无序、且不含重复元素的序列，集合主要用来进行成员关系测试和删除重复元素。

1.写法

可以使用大括号{}或者set()函数创建集合

    #自动去除重复元素
    set1 = {1,3,5,5,3,1}
    print(set1)
    # {1, 3, 5}
    
    #成员是否在集合中
    5 in set1
    # True
    8 in set1
    # False

2.常见操作

• 集合的并

    set1 = {1, 2, 3}
    set2 = {2, 4, 5}
    #集合的并
    set1 | set2 
    # {1, 2, 3, 4, 5}

• 集合的交

    #集合的交
    set1 & set2 
    # {2}

• 集合的差

    #集合的差(在set1不在set2中的元素)
    set1 - set2
    # {1, 3}

• 集合的补(两个集合中不同时存在的元素集合)

    #集合的补
    set1 ^ set2
    # {1, 3, 4, 5}
    
    #相当于并集与交集的差
    (set1 | set2) - (set1 & set2)
    # {1, 3, 4, 5}

七、Dictionary字典

1.写法

字典是一种映射类型，用“{ }”标识，它是一个无序的 键(key) : 值(value) 对集合
键必须使用不可变类型，在同一个字典中，键是唯一的

    dict1 = {"name":"giggle", "height":176, "weight":72}

2.存取方式

字典当中的元素是通过键来存取的

    dict1["height"]
    # 176

3.常见操作

• 修改字典某项的值

    dict1["weight"] = 73
    print(dict1)
    # {'name': 'giggle', 'height': 176, 'weight': 73}

• 在字典中增加一项

    dict1["sex"] = "M"
    print(dict1)
    # {'name': 'giggle', 'height': 176, 'weight': 73, 'sex': 'M'}

• 构建空字典

    dict2 = {}
    print(dict2)
    # {}

• 通过元组序列构造字典

    dict2 = dict([('name', 'giggle'),('height', 176)])
    print(dict2)
    # {'name': 'giggle', 'height': 176}
    
    dict2 = dict(name = 'giggle', weight = 72)
    print(dict2)
    # {'name': 'giggle', 'weight': 72}

• 内置函数

    #查看字典的键名
    dict2.keys()
    # dict_keys(['name', 'weight'])
    
    #查看字典的值
    dict2.values()
    # dict_values(['giggle', 72])
    
    #清空字典
    dict2.clear()
    print(dict2)
    # {}

八、格式化输出

1. print的字符串格式化符号

• %c 格式化字符串及其ASCII码

    print("%c" % "A")
    print("%c" % 65)
    # A
    # A

• %s 格式化字符串

    print("%s" % "Hello World")
    # Hello World

• %d 格式化整数

    print("%d" % 10)
    # 10

• %o 格式化无符号八进制数

    print("%o" % 10)
    # 12

• 格式化十六进制数(在前面显示'0x'或'0X')

    print("%#x" % 20)
    # 0x14
    print("%#X" % 20)
    # 0X14

• %f 格式化浮点数字，可指定小数点后的精度

    print("%f" % 3.14)
    # 3.140000

• %e 用科学计数法格式化浮点数

    print("%e" % 3140000)
    # 3.140000e+06

• %g 根据输入数字确定普通/科学计数法

    print("%g" % 3140000)
    print("%g" % 314000)
    # 3.14e+06
    # 314000

2.格式化操作符辅助指令

    # m.n.  是显示的最小总宽度，n是小数点后的位数
    print("%5.2f" % 31400.1234) #原长度超过5位，仍保留5位
    print("%5.2f" % 3.1234) #不足5位，右对齐，前面补空格
    # 31400.12
    #  3.12
              
    # -左对齐补位 
    print("%10.6f" % 3.1234)
    print("%-10.6f" % 3.1234)
    #   3.123400
    # 3.123400 
    
    # +在正数前面显示加号 
    print("%+10.6f" % 3.1234)
    #  +3.123400
    
    # 用*从后面的元组中读取字段宽度或精度
    pi = 3.1415926
    print("pi = %.*f" % (5,pi))
    # pi = 3.14159
    
    #通过变量填充格式控制字符串
    print("I like %s and can eat %.2f kg." % ("orange", 1.5))
    # I like orange and can eat 1.50 kg.
    
    #使用字典来对应填充
    print("I like %(fruit_name)s and can eat %(weight).2f kg." % {"fruit_name":"orange", "weight":1.5})
    # I like orange and can eat 1.50 kg.
    

九、类型转换

数据类型的转换，只需要将数据类型作为函数名即可使用，这些函数返回一个新的对象，表示转换的值，如：int(), float()和str()等。

1. 整型-字符串转换

    x = "6"
    print(x, type(x))
    x = int("6")
    print(x, type(x))
    输出结果：6 <class 'str'>
             6 <class 'int'>
             
    str(4)
    输出结果：'4'

2. ASCII码-字符转换

    #查看 ASCII 码
    ord("a")
    # 97
    
    #根据 ASCII 码转换成对应字符
    chr(65)
    # 'A'

3. 元组-列表/集合转换

    tuple1 = (1, 2, 3, 4, 4, 1)
    list1 = list(tuple1)
    set1 = set(tuple1)
    print(tuple1)
    print(list1)
    print(set1)
    #  (1, 2, 3, 4, 4, 1)
    #  [1, 2, 3, 4, 4, 1]
    #  {1, 2, 3, 4}

4. 元组-字典转换

    tuple1 = (("name", "giggle"), ("height", 176))
    dict1 = dict(tuple1)
    print(tuple1)
    print(dict1)
    #  (('name', 'giggle'), ('height', 176))
    #  {'name': 'giggle', 'height': 176}

5.超强的表达式计算(表达式字符串到数值的转换)

    x = 8 
    calc = "5 * x + 9 "
    eval(calc)
    # 49

十、程序结构与控制语句

1. Python的行

可以用( \ )将一行的语句分为多行显示

    thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable1 = 1
    thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable2 = 2
    thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable3 = 3
    plusResult = thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable1 +\
    thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable2 +\
    thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable3
    
    print(plusResult)
    #6

语句中包含[ ], { }或( )括号中间换行的就不需要使用多行连接符

    days = ('Monday', 'Tuesday', 'Wednesday',
            'Thursday', 'Friday', 'Saturday', 'Sunday')

2. 三种基本结构

顺序、条件(选择、分支)、循环

3. 条件语句

代码块是通过缩进来指示的，缩进代表一个代码块的开始，逆缩进表示一个代码块的结束
声明以冒号：字符结束，并且开启一个缩进级别

    # 语法格式 1
    if 条件表达式:
        语句块1
    else:
        语句块2
        
    #示例 1    
    print("请输入体重(kg):")
    weight = float(input())
    
    if weight > 50:
        print("少吃点！！！")
    else:
        print("好好吃饭！")
    # 请输入体重(kg):
    # 100
    # 少吃点！！！
    # 请输入体重(kg):
    # 45
    # 好好吃饭！

    #语法格式 2
    if 条件表达式:
        语句块1
    elif 条件表达式2:
        语句块2
    else:
        语句块3
        
    #示例 2：计算BMI指数
    print("请输入体重(kg):")
    weight = float(input())
    print("请输入身高(m)")
    height = float(input())
    
    BMI = weight / height **2
    
    if BMI < 20:
        print("你的BMI指数是%.2f，太轻了哦！" %BMI)
    elif BMI > 25:
        print("你的BMI指数是%.2f，太重了哦！" %BMI)
    else:
        print("你的BMI指数是%.2f，非常正常，请保持！" %BMI)
    # 请输入体重(kg):
    # 72
    # 请输入身高(m)
    # 1.76
    # 你的BMI指数是23.24，非常正常，请保持！

4. 循环语句

• while 循环

    #语法格式
    while 条件表达式:
        语句块
        
    #统计6在2的100次方中出现的次数
    num = 2 ** 100
    print(num)
    
    count = 0
    
    while num > 0:
        if num % 10 == 6:
            count = count + 1
        num = num // 10
    
    print(count)
    # 1267650600228229401496703205376
    # 5

• for 循环

    #语法格式
    for 循环变量 in 序列:
        语句块
    
    #统计6在2的100次方中出现的次数
    num = 2 ** 100
    print(num)
    count = 0
    for digit in str(num): #转换成字符串(字符串是特殊的列表，列表的每一项会赋值给digit)
        if digit == "6":
            count = count + 1
    print(count)
    # 1267650600228229401496703205376
    # 5

• 使用for和range来枚举列表中的元素

    for i in range(3):
        print(i)
    # 0
    # 1
    # 2
    
    for x in range(1, 3):
        print(x) #结果不包含最后的 3
    # 1
    # 2

5. 列表推导式

提供了一个创建和操作列表的有力工具

• 由一个表达式以及紧跟这个表达式的 for 语句构成，for 语句还可以跟 0 或多个 if 或 for 语句

    lst1 = [1, 2, 3]
    lst2 = [3, 4, 5]
    [x * y for x in lst1 for y in lst2]
    # [3, 4, 5, 6, 8, 10, 9, 12, 15]

• 数值判断可以链接使用，例如 1<x<3 能够判断变量 x 是否在1和3之间

    [x for x in lst1 if 4 > x > 1]
    # [2, 3]

6. 多重循环

    #9*9乘法口诀表
    for i in range(1, 10):
        for j in range(1, i+1):
            result = j * i
            print('%s x %s = %-5s' % (j, i, result), end = '') #end=''表示不需要换行
        print() #换行
# 1 x 1 = 1    
# 1 x 2 = 2    2 x 2 = 4    
# 1 x 3 = 3    2 x 3 = 6    3 x 3 = 9    
# 1 x 4 = 4    2 x 4 = 8    3 x 4 = 12   4 x 4 = 16   
# 1 x 5 = 5    2 x 5 = 10   3 x 5 = 15   4 x 5 = 20   5 x 5 = 25   
# 1 x 6 = 6    2 x 6 = 12   3 x 6 = 18   4 x 6 = 24   5 x 6 = 30   6 x 6 = 36   
# 1 x 7 = 7    2 x 7 = 14   3 x 7 = 21   4 x 7 = 28   5 x 7 = 35   6 x 7 = 42   7 x 7 = 49   
# 1 x 8 = 8    2 x 8 = 16   3 x 8 = 24   4 x 8 = 32   5 x 8 = 40   6 x 8 = 48   7 x 8 = 56   8 x 8 = 64   
# 1 x 9 = 9    2 x 9 = 18   3 x 9 = 27   4 x 9 = 36   5 x 9 = 45   6 x 9 = 54   7 x 9 = 63   8 x 9 = 72   9 x 9 = 81           

7. break语句

break 语句用在 while 和 for 循环中
break 语句用来终止循环语句，即循环条件没有 False 或者序列还没被完全递归完，也会停止执行循环语句

    #统计第1个9在2的100次方中出现的位置
    num = 2 ** 100
    pos = 0
    for digit in str(num):
        pos = pos + 1
        if digit == '9':
            break
    print("2**100 is: %d \nthe first position of 9 is Pos.%d" %(num, pos))
    # 2**100 is: 1267650600228229401496703205376 
    # the first position of 9 is Pos.16

如果在嵌套循环中，break语句将停止执行本层的循环

    #求 2到10之间的素数
    i = 2
    while(i < 10):
        flag = 0
        j = 2
        while(j <= (i / j)): 
            if i % j == 0: #i能被j整除，一定不是素数，不必继续判断i能否被>j的数整除
                flag = 1 
                break
            j = j + 1
        if(flag == 0):
            print(i, "是素数")
        i = i + 1    
    # 2 是素数
    # 3 是素数
    # 5 是素数
    # 7 是素数

8. continue语句

continue语句用来跳过当前循环的剩余语句，然后继续进行下一轮循环

    #求在2的100次方中删除所有的9后的数字
    num = 2 ** 100
    without9 = ''
    for digit in str(num):
        if digit == "9":
            continue
        without9 += digit
    print("2**100 is: %d\nwithout 9 is :%s" %(num, without9))    
    # 2**100 is: 1267650600228229401496703205376
    # without 9 is :12676506002282240146703205376

9. pass语句

pass是空语句，是为了保持程序结构的完整性，一般用做占位语句

    #求在2的100次方中删除所有的9后的数字
    num = 2 ** 100
    without9 = ''
    for digit in str(num):
        if digit == "9":
            pass
        else:    
            without9 += digit
    print("2**100 is: %d\nwithout 9 is :%s" %(num, without9))    
    # 2**100 is: 1267650600228229401496703205376
    # without 9 is :12676506002282240146703205376

10. 函数

Python提供了许多内建函数，如print()
开发者也可以自己创建用户自定义函数

    #函数定义语法
    def functionname( parameters ):
        "函数_文档字符串"
        function_suite
        return [expression]
    
    #定义一个求n!的函数，并调用求5！    
    def fact(n):
        result = 1
        for i in range(1, n+1):
            result = result * i
        return result
    fact(5) #调用函数
    # 120

可选参数以集合的方式出现在函数声明中并紧跟着必选参数，可选参数可以在函数声明中被赋予一个默认值。已命名的参数需要赋值。

    #intp 和 stringp 是可选参数，有默认值
    #如果调用fun_example时只指定一个参数，那么 intp 缺省为 0，stringp 缺省为A default string
    #如果调用fun_example时只指定两个参数，那么 stringp 仍缺省为A default string
    # listp是必备参数，因为它没有指定缺省值
    def fun_example(listp, intp = 0, stringp = "A default string"):
        "这是一个复杂的例子，所以我在此处写了帮助文档信息"
        listp.append("A new item")
        intp += 1
        return listp, intp, stringp
    my_list = [1, 2, 3]
    my_int = 10
    print(fun_example(my_list, my_int))
    print(my_list)
    # ([1, 2, 3, 'A new item'], 11, 'A default string')
    # [1, 2, 3, 'A new item']

函数的第一行语句可以选择性地使用文档字符串——用于存放函数说明

    #打印函数的帮助文档信息
    fun_example.__doc__
    # '这是一个复杂的例子，所以我在此处写了帮助文档信息'

函数可以返回一个元组(使用元组拆包可以有效返回多个值)

    v1, v2, v3 = fun_example(my_list, my_int)
    print(v1)
    print(v2)
    print(v3)
    # [1, 2, 3, 'A new item']
    # 11
    # A default string

11. 全局变量和局部变量

全局变量在函数之外声明

    number = 5  #全局变量
    def fun1():
        print(number)
    fun1()
    print(number)
    # 5
    # 5

局部变量在函数内容声明

    number = 5  
    def fun2():
        number = 3 #局部变量
        print(number)
    fun2()
    print(number)
    # 3
    # 5

全局变量可以不需要任何特殊的声明即能读取，但如果想要修改全局变量的值，就必须在函数开始之处用global关键字进行声明，否则Python会将此变量按照新的局部变量处理。

    number = 5  
    def fun3():
        global number #声明后修改全局变量
        number = 3
        print(number)
    fun3()
    print(number)
    # 3
    # 3

函数参数也是局部变量，不需要在函数内部重复定义

    #定义一个求 n!的函数
    def fact(n):
        result = 1
        for i in range(1, n+1):
            result = result * i
        return result
    fact(5) #5赋值给函数参数 n作为局部变量    
    # 120

12. 类

类用来描述具有相同的属性和方法的对象的集合
它定义了该集合中每个对象所共有的属性和方法

    #语法格式
    #使用 class语句来创建新类，class之后为类的名称并以冒号结尾
    class ClassName:
        '类的帮助信息' #类文档字符串
        class_suite #类体，由类成员、方法、数据属性组成
    
    #定义一个类
    class DeepLearner(object):
    'DeepLearner是深度学习者的类，这是有关这个类的帮助文档'
    #learnerCount 变量是一个类的属性，它的值将在这个类的所有实例之间共享
    #你可以在内部类或外部类使用DeepLearner.learnerCount访问
    learnerCount = 0
    
    #__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
    #类的方法与普通函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，按照惯例它的名称是 self
    #self 代表类的实例，参数self 在定义类的方法时是必须要的，虽然在调用时不必传入相应的参数
    def __init__(self, name, schoolName):
        self.name = name
        self.schoolName = schoolName
        DeepLearner.learnerCount = DeepLearner.learnerCount +1
    def getName(self):
        return self.name
    def getSchoolName(self):
        return self.schoolName
    def displayCount(self):
        print("Total DeepLearner count is %d" % DeepLearner.learnerCount)
    def displayLearner(self):
        print("Name: %s, School: %s" % (self.name, self.schoolName))
        

打印类帮助文档

    print(DeepLearner.__doc__)
    # DeepLearner是深度学习者的类，这是有关这个类的帮助文档

对象是类的实例，实例化类其它编程语言中一般用new，但是Python中没有这个关键字

    #新建对象
    newLearner1 = DeepLearner('lucky','Fuzhou University')
    newLearner2 = DeepLearner('happy','Xiamen University')
    #使用点号.访问对象的属性和方法
    print(DeepLearner.learnerCount)
    print(newLearner1.getName(), newLearner1.getSchoolName())
    print(newLearner2.getName(), newLearner2.getSchoolName())
    newLearner1.displayLearner()
    newLearner2.displayLearner() 
    # 2
    # lucky Fuzhou University
    # happy Xiamen University
    # Name: lucky, School: Fuzhou University
    # Name: happy, School: Xiamen University

13. 文件

Python针对文件的处理有很多内建的函数库可以调用

    #写文件
    with open("test.txt", "wt") as out_file: #写入到当前Python执行的目录下的test.txt中
        out_file.write("该文本会写入文件中\n看到我了吧！")
    #读取文件
    with open("test.txt", "rt") as in_file:
        text = in_file.read()
    print(text)
    # 该文本会写入文件中
    # 看到我了吧！

14. 异常

Phython中的异常由 try-except[exceptionname] 块处理

    def except_function():
        try:
            #故意除零
            10 / 0
        except ZeroDivisionError: #除零异常名 ZeroDivisionError
        #若不知道可能发生什么异常，可不指定，直接用 except:
            print("发生除零异常啦")
        else:
            #正常情况
            print("一切正常哦")
            pass
        finally:
            #无论是否发生异常都将执行最后的代码
            print("这是必然执行的代码块呀")
    
    except_function()
    # 发生除零异常啦
    # 这是必然执行的代码块呀

15. 导入外部库

外部库可以使用 import[libname] 关键字来导入
可以用 from[libname] import [funcname] 来导入所需要的函数

    import random  #导入random库
    from time import time #导入具体time函数
    import numpy as np #导入numpy库取别名np
    import matplotlib.pyplot as plt #导入绘图函数库取别名plt
    
    randomint = random.randint(1, 100) #在1-100之间产生的随机数
    print(randomint)
    
    startTime = time()
    print(startTime)
    
    # 75
    # 1581313764.6087253
    
    #直接采用np生成等差数列的方法，生成100个点，每个点的取值在-1~1之间
    x_data = np.linspace(-1, 1, 100)
    #y = 2x + 1
    y_data = 2 * x_data + 1.0
    
    #在Jupyter中，使用matplotlib显示图像需要设置为 inline模式，否则不会显示图像
    %matplotlib inline
    
    plt.figure()
    plt.scatter(x_data, y_data) #画出随机生成数据的散点图
    
    #显示运行的总时间
    duration = time() - startTime
    print(duration)

image

16. 获取帮助信息

调用help() 来获取一个对象是如何工作的

    help(int)

调用dir()来显示该对象的所有方法

    dir(int)

输入时打出.加tab键可查看可调用的方法