5896784843701866315830202306247774762972638982405042480372238189012365044783448228280875028875684277127088378956152713197320945688565673304729984010537727226637040943165593052367979000124463424161858464934947067680269075228341562695042312463815883441507512003942871781958205145461989665812045325106145074842960481661294209203262577314061569045152694421556602495323466256365196176516277494056642637786305854049111948156579863012416891273717889898672613595960001

浮點數

浮點數也就是小數，之所以稱為浮點數，是因為按照科學記數法表示時，一個浮點數的小數點位置是可變的，比如，1.23x109和12.3x108是完全相等的。浮點數可以用數學寫法，如1.23，3.14，-9.01，等等。但是對於很大或很小的浮點數，就必須用科學計數法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以寫成1.2e-5，等等。

整數和浮點數在計算機內部儲存的方式是不同的，整數運算永遠是精確的（除法難道也是精確的？是的！），而浮點數運算則可能會有四捨五入的誤差。

0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1

0.7999999999999999

複數

複數是指能寫成如下形式的數a+bi,這裡a和b是實數，i是虛數單位(即-1開根)。在複數a+bi中，a稱為複數的實部，b稱為複數的虛部，i稱為虛數單位。當虛部等於零時，這個複數就是實數；當虛部不等於零時，這個複數稱為虛數

#複數由實數部分和虛數部分構成，可以用a + bj,或者complex(a,b)表示， 複數的實部a和虛部b都是浮點型

complex(1,5)

(1+5j)

有理數

數學上，有理數是一個整數a和一個非零整數b的比，例如3/8，通則為a/b，又稱作分數。0也是有理數。有理數是整數和分數的集合，整數也可看做是分母為一的分數。有理數的小數部分是有限或為無限迴圈的數。不是有理數的實數稱為無理數，即無理數的小數部分是無限不迴圈的數。

無理數

無理數，也稱為無限不迴圈小數，不能寫作兩整數之比。若將它寫成小數形式，小數點之後的數字有無限多個，並且不會迴圈。常見的無理數有非完全平方數的平方根、圓周率（Pi）和e

實數

實數，是有理數（有限或為無限迴圈的數）和無理數（無限不迴圈小數）的總稱。

科學記數法

把一個絕對值大於10的實數記為a×10n的形式(1≤|a|<10，n為整數),這種記數法叫做科學記數法。這是一種記數的方法。例如19971400000000=1.99714×10^13。計算器或電腦表達10的的冪是一般是用E或e，也就是1.99714E13=19971400000000

不同進製表示

0o數字 0O數字表示八進位制整數 0o24
0x數字 0X數字表示十六進位制整數 0x3F ,0X3F
0b數字 0B數字表示二進位制整數 0b101 ， 0B101

數值型別轉換

bin()將整數x轉換為二進位制字串
chr(i) 返回整數i對應的ASCII字元。與ord()作用相反。i取值[0,255]之間的正數
ord() 一個字串表示的字元轉換為字元相對應的整數
int() 將一個數轉化為整數
long(x [,base ]) 將x轉換為一個長整數
float(x ) 將x轉換到一個浮點數
complex(real [,imag ]) 建立一個複數
str() 一般是將數值轉成字串

r = bin(10)
print('將整數10轉換為二進位制字串:%s'%r)

c = chr(66)
print('整數66對應的ASCII字元:%s'%c)

i = ord("t")
print('字元t轉換對應的整數%s'%i)

r= int(12.0)
print("浮點數12.0轉換為整數%s"%r)
print("浮點數12.0轉換為整數%d"%r)

print("將0xb用十進位制數表示%s"%int("0xb",16))
print("將八進位制10用十進位制數表示%s"%int("10",8))
print("將字元10用十進位制數表示%s"%int("10",16))
print("將字元10用十進位制數表示%s"%int("10",10))

a = 1.524464444444444444
b = float('%.4f'%a)
print("控制精度，保留4位小數，結果為：%s"%b)

print('字元37.21轉換為浮點數：%s'%float('37.21'))
print('整數234轉換為浮點數：%s'%float(234))

print('整數234轉換為字元：%s'%str(234))

將整數10轉換為二進位制字串:0b1010
整數66對應的ASCII字元:B
字元t轉換對應的整數116
浮點數12.0轉換為整數12
浮點數12.0轉換為整數12
將0xb用十進位制數表示11
將八進位制10用十進位制數表示8
將字元10用十進位制數表示16
將字元10用十進位制數表示10
控制精度，保留4位小數，結果為：1.5245
字元37.21轉換為浮點數：37.21
整數234轉換為浮點數：234.0
整數234轉換為字元：234

hex(x) 將一個整數轉換為一個十六進位制字串
oct(x ) 將一個整數轉換為一個八進位制字串

print("將整數12轉換為十六進位制為%s"%hex(2))
print("將整數12轉換為八進位制為%s"%oct(12))
print("將0xb用十進位制數表示%s"%int("82d1",16))

將整數12轉換為十六進位制為0x2
將整數12轉換為八進位制為0o14
將0xb用十進位制數表示33489

資料型別資訊獲取

#函式type()，直接給出數的資料型別
print(type(12.0))
print(type(False))
print(type(1000))

<class 'float'>
<class 'bool'>
<class 'int'>

#函式isinstance()需要給出需要判斷的數和一個數據型別
print(isinstance('I love u',float))
print(isinstance('I love u',str))

False
True

isinstance 和 type 的區別在於：

type()不會認為子類是一種父類型別。
isinstance()會認為子類是一種父類型別。

class A:
    pass

class B(A):
    pass

print(isinstance(A(), A))

print(type(A()) == A )

print(isinstance(B(), A))
print(type(B()) == A)

print(type(A()))
print(type(B()))

print(type(A()))
print(type(B()))

True
True
True
False
<class '__main__.A'>
<class '__main__.B'>
<class '__main__.A'>
<class '__main__.B'>

math 模組、cmath 模組

Python 中數學運算常用的函式基本都在 math 模組、cmath 模組中。

Python math 模組提供了許多對浮點數的數學運算函式。

Python cmath 模組包含了一些用於複數運算的函式。

cmath 模組的函式跟 math 模組函式基本一致，區別是 cmath 模組運算的是複數，math 模組運算的是數學運算。

import math
# 檢視 math 檢視包中的內容:
# dir(math)

python數學函式

函式	返回值 ( 描述 )
abs(x)	返回數字的絕對值，如abs(-10) 返回 10
ceil(x)	返回數字的上入整數，如math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1(python3中不存在)
exp(x)	返回e的x次冪(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回數字的絕對值，如math.fabs(-10) 返回10.0
floor(x)	返回數字的下舍整數，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10為基數的x的對數，如math.log10(100)返回 2.0
max(x1, x2,…)	返回給定引數的最大值，引數可以為序列。
min(x1, x2,…)	返回給定引數的最小值，引數可以為序列。
modf(x)	返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示。
pow(x, y)	x**y 運算後的值。
round(x [,n])	返回浮點數x的四捨五入值，如給出n值，則代表舍入到小數點後的位數。
sqrt(x)	返回數字x的平方根

abs(x)

print("abs(-45) : ", abs(-45)) 
print("abs(100.12) : ", abs(100.12))
print("abs(119) : ", abs(119))

abs(-45) :  45
abs(100.12) :  100.12
abs(119) :  119

ceil()

import math   # This will import math module

print("math.ceil(-45.17) : ", math.ceil(-45.17))
print("math.ceil(100.12) : ", math.ceil(100.12))
print("math.ceil(100.72) : ", math.ceil(100.72)) 
print("math.ceil(119) : ", math.ceil(119)) 
print("math.ceil(math.pi) : ", math.ceil(math.pi))

math.ceil(-45.17) :  -45
math.ceil(100.12) :  101
math.ceil(100.72) :  101
math.ceil(119) :  119
math.ceil(math.pi) :  4

cmp()

Python 3.X 的版本中已經沒有 cmp 函式，如果你需要實現比較功能，需要引入 operator 模組，適合任何物件，包含的方法有：

operator.lt(a, b)
operator.le(a, b)
operator.eq(a, b)
operator.ne(a, b)
operator.ge(a, b)
operator.gt(a, b)
operator._lt_(a, b)
operator._le_(a, b)
operator._eq_(a, b)
operator._ne_(a, b)
operator._ge_(a, b)
operator._gt_(a, b)

#print("cmp(80, 100) : ", cmp(80, 100))
import operator
print(operator.eq('hello', 'name'))
print(operator.lt(80,100))
print(operator.__lt__(80,100))

False
True
True

exp()

import math   # 匯入 math 模組

print ("math.exp(-45.17) : ", math.exp(-45.17))
print ("math.exp(100.12) : ", math.exp(100.12))
print ("math.exp(100.72) : ", math.exp(100.72))
print ("math.exp(math.pi) : ", math.exp(math.pi))

math.exp(-45.17) :  2.4150062132629406e-20
math.exp(100.12) :  3.0308436140742566e+43
math.exp(100.72) :  5.522557130248187e+43
math.exp(math.pi) :  23.140692632779267

fabs()

fabs() 函式類似於 abs() 函式，但是他有兩點區別:

abs() 是內建函式。 fabs() 函式在 math 模組中定義。
fabs() 函式只對浮點型跟整型數值有效。 abs() 還可以運用在複數中。

import math  

print ("math.fabs(-45.17) : ", math.fabs(-45.17))
print ("math.fabs(100.12) : ", math.fabs(100.12))
print ("math.fabs(100.72) : ", math.fabs(100.72))
print ("math.fabs(math.pi) : ", math.fabs(math.pi))

math.fabs(-45.17) :  45.17
math.fabs(100.12) :  100.12
math.fabs(100.72) :  100.72
math.fabs(math.pi) :  3.141592653589793

floor()

import math   

print ("math.floor(-45.17) : ", math.floor(-45.17))
print ("math.floor(100.12) : ", math.floor(100.12))
print ("math.floor(100.72) : ", math.floor(100.72))
print ("math.floor(math.pi) : ", math.floor(math.pi))

math.floor(-45.17) :  -46
math.floor(100.12) :  100
math.floor(100.72) :  100
math.floor(math.pi) :  3

log()

import math  

print ("math.log(100.12) : ", math.log(100.12))
print ("math.log(100.72) : ", math.log(100.72))
print ("math.log(math.pi) : ", math.log(math.pi))

math.exp(math.log(100.12))

math.log(100.12) :  4.6063694665635735
math.log(100.72) :  4.612344389736092
math.log(math.pi) :  1.1447298858494002





100.12

log10()

import math   

print ("math.log10(100.12) : ", math.log10(100.12))
print ("math.log10(100.72) : ", math.log10(100.72))
print ("math.log10(119) : ", math.log10(119))
print ("math.log10(math.pi) : ", math.log10(math.pi))

math.log10(100.12) :  2.0005208409361854
math.log10(100.72) :  2.003115717099806
math.log10(119) :  2.075546961392531
math.log10(math.pi) :  0.4971498726941338

max()

print ("max(80, 100, 1000) : ", max(80, 100, 1000))
print ("max([80, 100, 1000]) : ", max([80, 100, 1000]))
print ("max(-20, 100, 400) : ", max(-20, 100, 400))
print ("max(-80, -20, -10) : ", max(-80, -20, -10))
print ("max(0, 100, -400) : ", max(0, 100, -400))

max(80, 100, 1000) :  1000
max([80, 100, 1000]) :  1000
max(-20, 100, 400) :  400
max(-80, -20, -10) :  -10
max(0, 100, -400) :  100

min()

print ("min(80, 100, 1000) : ", min(80, 100, 1000))
print ("min(-20, 100, 400) : ", min(-20, 100, 400))
print ("min(-80, -20, -10) : ", min(-80, -20, -10))
print ("min(0, 100, -400) : ", min(0, 100, -400))

min(80, 100, 1000) :  80
min(-20, 100, 400) :  -20
min(-80, -20, -10) :  -80
min(0, 100, -400) :  -400

modf()

import math   

print ("math.modf(100.12) : ", math.modf(100.12))
print ("math.modf(100.72) : ", math.modf(100.72))
print ("math.modf(119) : ", math.modf(119))
print ("math.modf(math.pi) : ", math.modf(math.pi))

math.modf(100.12) :  (0.12000000000000455, 100.0)
math.modf(100.72) :  (0.7199999999999989, 100.0)
math.modf(119) :  (0.0, 119.0)
math.modf(math.pi) :  (0.14159265358979312, 3.0)

pow()

pow() 通過內建的方法直接呼叫，內建方法會把引數作為整型，而 math 模組則會把引數轉換為 float

import math  

print ("math.pow(100, 2) : ", math.pow(100, 2))
print("使用內建，檢視輸出結果區別")
print ("pow(100, 2) : ", pow(100, 2))
print ("math.pow(100, -2) : ", math.pow(100, -2))
print ("math.pow(2, 4) : ", math.pow(2, 4))
print ("math.pow(3, 0) : ", math.pow(3, 0))

math.pow(100, 2) :  10000.0
使用內建，檢視輸出結果區別
pow(100, 2) :  10000
math.pow(100, -2) :  0.0001
math.pow(2, 4) :  16.0
math.pow(3, 0) :  1.0

round()

print ("round(70.23456) : ", round(70.23456))
print ("round(56.659,1) : ", round(56.659,1))
print ("round(80.264, 2) : ", round(80.264, 2))
print ("round(100.000056, 3) : ", round(100.000056, 3))
print ("round(-100.000056, 3) : ", round(-100.000056, 3))

round(70.23456) :  70
round(56.659,1) :  56.7
round(80.264, 2) :  80.26
round(100.000056, 3) :  100.0
round(-100.000056, 3) :  -100.0

sqrt()

import math 

print ("math.sqrt(100) : ", math.sqrt(100))
print ("math.sqrt(7) : ", math.sqrt(7))
print ("math.sqrt(math.pi) : ", math.sqrt(math.pi))

math.sqrt(100) :  10.0
math.sqrt(7) :  2.6457513110645907
math.sqrt(math.pi) :  1.7724538509055159

python隨機數函式

隨機數可以用於數學，遊戲，安全等領域中，還經常被嵌入到演算法中，用以提高演算法效率，並提高程式的安全性

函式	描述
choice(seq)	從序列的元素中隨機挑選一個元素，比如random.choice(range(10))，從0到9中隨機挑選一個整數。
randrange	([start,] stop [,step]) 從指定範圍內，按指定基數遞增的集合中獲取一個隨機數，基數預設值為1
random()	生成一個0到1的隨機浮點數，0<=n<1.0
seed([x])	改變隨機數生成器的種子seed。如果你不瞭解其原理，你不必特別去設定seed，Python會幫你選擇seed
shuffle(lst)	將序列的所有元素隨機排序
uniform(x, y)	生成一個指定範圍的隨機浮點數，它在[x,y]範圍內
randint(x, y)	生成一個指定範圍內的整數，它在[x,y]範圍內
sample	從指定序列中隨機獲取指定長度的片斷

choice()

import random

print ("從 range(100) 返回一個隨機數 : ",random.choice(range(100)))
print ("從列表中 [1, 2, 3, 5, 9]) 返回一個隨機元素 : ", random.choice([1, 2, 3, 5, 9]))
print ("從字串中 'Runoob' 返回一個隨機字元 : ", random.choice('Runoob'))

從 range(100) 返回一個隨機數 :  28
從列表中 [1, 2, 3, 5, 9]) 返回一個隨機元素 :  5
從字串中 'Runoob' 返回一個隨機字元 :  n

randrange()

import random
 
# 從 1-100 中選取一個奇數
print ("randrange(1,100, 2) : ", random.randrange(1, 100, 2))
 
# 從 0-99 選取一個隨機數
print ("randrange(100) : ", random.randrange(100))

#從[10,12,14,16,...,96,98]序列中獲取一個隨機數
print("random.randrange(10,100,2):",random.randrange(10,100,2))

randrange(1,100, 2) :  25
randrange(100) :  7
random.randrange(10,100,2): 62

random()

import random

# 第一個隨機數
print ("random() : ", random.random())

# 第二個隨機數
print ("random() : ", random.random())


# 實現 100-120 隨機小數
print((random.random()*20)+100)

random() :  0.1605165979964044
random() :  0.4380019858706685
115.4696868547905

seed()

import random

random.seed()
print ("使用預設種子生成隨機數：", random.random())
random.seed()
print ("使用預設種子生成隨機數：", random.random())

random.seed(10)
print ("使用整數種子生成隨機數：", random.random())
random.seed(10)
print ("使用整數種子生成隨機數：", random.random(
              
           
              
              
            
            相關推薦
			   
            
            
            
 

    

    
    python資料型別01
       
 
  
  
 
 
  文章目錄
  
   數值型別
   
    整型(int)
    
     long（長整型）
    
    浮點數
    複數
    不同進製表示
    數值型別轉換
    資料型別資訊獲取
    math 模組、cmath 模組
    python數 

  
 

    

    
    Python從入門到放棄_資料型別01
      1.整型 
　　在32 位系統中 可用的數字範圍: 
　　　　32 -2 **31 ~ 2**31-1 
　　在64 位的系統中,可用的數字範圍: 
　　　　# 64 -2 **63 ~ 2**63-1 
　　整型(int)的型別 
　　long: 
　　 python 

  
 

    

    
    第二篇 Python資料型別、字元編碼、檔案處理
      
 一、引子
     1、什麼是資料？
         x=10，10是我們要儲存的資料
     2、為何資料要分不同的型別
     

  
 

    

    
    python資料型別（string/list/tuple/dict）內建方法
       
 
 Python 字串常用方法總結 
 明確：對字串的操作方法都不會改變原來字串的值 
 1，去掉空格和特殊符號 
 name.strip()  去掉空格和換行符 
 name.strip('xx')  去掉某個字串 
 name.lstrip()  去掉左邊的空格和換行符 

  
 

    

    
    python資料型別之列表(list)和其常用方法
      列表是python常用資料型別之一，是可變的，可由n = []建立，也可由n = list()建立，第一種方法更常用。 
  
常用方法總結： 
  
 
 # 建立方法  n = [] 或者 n = list()

# index 查詢索引值
li = ['Edward', 'Mark' 

  
 

    

    
    python資料型別之字典(dict)和其常用方法
      字典的特徵： 
key-value結構key必須可hash,且必須為不可變資料型別、必須唯一。  # hash值都是數字，可以用類似於2分法(但比2分法厲害的多的方法）找。可存放任意多個值、可修改、可以不唯一無序查詢速度快常用方法： 
 
 info = {'stu01': 'alex', 'stu02':  

  
 

    

    
    python資料型別之集合(set)和其常用方法
      集合是一個無序的，不重複的資料組合作用(集合的重點)：1.去重，把一個列表變成集合就自動去重了2.關係測試，測試兩組資料庫之前的交集、差集、並集等關係 
 
 s = {1, 1, 2, 2, 3, 4, 'a', 'a', '!', '!'}
print(type(s))  # <class 'set 

  
 

    

    
    一起學Python——資料型別詳解
      和學習其他程式語言一樣，首先要了解一門語言的資料型別。 
Python的資料型別有整型、浮點型、字串、布林型、日期時間型別、list列表、set集合、tuple元組、dict詞典等。 
1、整型 就是數學中的整數，包括負整數。 定義整型的方法： 
a = 100
b = -100
print(a)
print 

  
 

    

    
    Python 資料型別之 集合 set
      ####集合 
集合是無序的，不重複的資料集合，它裡面的元素是可雜湊的(不可變型別)，但是集合本身是不可雜湊（所以集合做不了字典的鍵）的。以下是集合最重要的兩點： 
1.去重，把一個列表變成集合，就自動去重了。 
2.關係測試，測試兩組資料之前的交集、差集、並集等關係。 
#建立集合 
 
 ##建立集合
s 

  
 

    

    
    Python資料型別（2）列表和元組
       
 
 列表和元組 
 列表和元組都屬於序列型別（sequence）。序列物件中的元素都是有序存放的，可以通過編號訪問其元素。兩者最大的區別在於列表是一種可變序列支援修改其元素，而元組是一種不可變序列，不能修改其元素。 
 
 列表 
 列表（list)是一種可變序列。列表用方括號定義，元素間用逗號隔開。列 

  
 

    

    
    Python資料型別（1）數字資料型別
       
 
 Python資料型別簡介 
 Python語言是面向物件的一門程式語言。Python中的資料型別其實就是Python的內建基本物件。內建物件主要包括簡單型別和容器型別。簡單型別主要是數值型資料，容器型別是可以包含其他物件的集體，如序列，元組，對映，集合等。Python中的資料型別也是物件，資料型別像 

  
 

    

    
    Python資料型別轉換規則
       
  
  
 Python 支援四種不同的數值型別，分別是整型、長整型、浮點型和複數，這些型別的資料有各自的特點，在使用過程中也可以進行型別轉換，具體轉換方法如下： int(x [,base ]) 將x轉換為一個整數 long(x [,base ]) 將x轉換為一個長整數 float(x ) 將x轉換到一 

  
 

    

    
    Python資料型別—運算子
       
  
  
 常用程式檔案字尾： 
  .py python檔案 
  .c c語言原始檔 
  .cpp c++語言檔案 
  .java java語言檔案 
 Python解釋執行器 
  Python（python2的解釋執行器） 
  Python3 
 Open terminal h 

  
 

    

    
    Python資料型別、運算子、流程語句（條件結構，迴圈結構）斐波那契數列、99乘法表（for，while）
       
  
  
 一、Python變數型別 
 型別 
  
  數值型、字串、元組、列表、字典等  例：c/c++、java是強型別的程式語言，一個變數在使用前確定型別，在程式期間，變數的型別是不能改變的；  指令碼語言：shell、python、perl、javaScript弱型別； 
  
 Pytho 

  
 

    

    
    python資料型別、if判斷語句
      　　python的資料型別： 
　　int（整型）　　float（浮點型）　　#相較c++，去除了char、long、longlong。。。 
　　str（字串）　　　　　　　　　   #同等c++ sting型別 
　　list（列表）　　dict（字典）　　　 #對比c，c++中的陣列 

  
 

    

    
    python資料型別之 集合
       
 
 1.集合的定義 
 格式：集合名 = {元素1，元素2，...} 
 例：my_set = {1, 3, 5} 
 集合是無序的-> 不支援下標索引 集合是可變的資料型別 
 集合中的元素是唯一的 
 集合一般用於元組或者列表中的元素去重 
 定義一個空的集合  my_set = s 

  
 

    

    
    Python-資料型別 主鍵auto_increment
      1.詳細的建表語句 *****    create table 表名(    欄位名1 資料型別[(長度) 約束條件],    欄位名2 資料型別[(長度) 約束條件]    );    解釋：        型別：使用限制欄位必須以什麼樣的資料型別傳值        約束條件：約束條件是在型別之外新增一種額 

  
 

    

    
    Python自動化學習筆記（四）——Python資料型別（集合set,元組tuple）、修改檔案、函式、random常用方法
      1.修改檔案的兩種方式 
 
 1 #第一種
2 with open('users','a+') as fw:  #用a+模式開啟檔案，使用with這種語法可以防止忘記close檔案
3     fw.seek(0)  #移動檔案指標到最前面，然後才能讀到內容
4     result=fw.read()   

  
 

    

    
    Python資料型別轉換函式
      資料型別轉換函式 
 
  
   
   函 數 
   作 用 
   
   
   int(x) 
   將 x 轉換成整數型別 
   
   
   float(x) 
   將 x 轉換成浮點數型別 
   
   
   complex(real[,imag]) 
   建立一個複數 
    

  
 

    

    
    Python資料型別str、list、tuple、dict、set
       
  
  
 字串 
  
  字串常見的功能 
  
 name = 'fe_cow'

print name.capitalize()  # 首字母大寫 :Fe_cow

print name.count('_')    # 統計字串出現在這個字元中的個數: 1

print name.center(