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
運算符 | 描述 | 實例 |
---|---|---|
+ | 加 | x+y 輸出13 |
- | 減 | x-y 輸出7 |
* | 乘 | x*y 輸出30 |
/ | 除 | x/y 輸出3.3333333333333335 |
% | 取模 | x%y 輸出1 |
** | 返回x的y次冪 | x**y 輸出1000 |
// | 取整除(向下取整) | x//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)
16. 獲取幫助信息
調用help() 來獲取一個對象是如何工作的
help(int)
調用dir()來顯示該對象的所有方法
dir(int)
輸入時打出.加tab鍵可查看可調用的方法