1——變量的定義
在 Python 中,每個變量 在使用前都必須賦值,變量 賦值以后 該變量 才會被創(chuàng)建,變量定義之后,后續(xù)就可以直接使用了,在ipython中,如果要查看變量內(nèi)容,直接輸入變量名即可,不需要使用 print 函數(shù)。如果使用解釋器執(zhí)行,如果要輸出變量的內(nèi)容,必須要要使用 print 函數(shù)。在內(nèi)存中創(chuàng)建一個變量,會包括:
1、變量的名稱
2、變量保存的數(shù)據(jù)
3、變量存儲數(shù)據(jù)的類型
4、變量的地址
在 Python 中定義變量時候需要指定類型,Python 可以根據(jù) = 等號右側(cè)的值,自動推導(dǎo)出變量中存儲數(shù)據(jù)的類型。在Python中,數(shù)據(jù)類型可以分為 數(shù)字型 和 非數(shù)字型。數(shù)字型又可以分為整型 (int)、浮點(diǎn)型(float)、布爾型(bool) (真 True 非 0 數(shù) —— 非零即真、假 False 0)、復(fù)數(shù)型 (complex主要用于科學(xué)計算)、非數(shù)字型(字符串、列表、元組、字典)。使用 type 函數(shù)可以查看一個變量的類型。type(name)即可。數(shù)字型變量之間是可以直接進(jìn)行計算的。如果變量是布爾型,在計算的時候True會轉(zhuǎn)化成1,F(xiàn)alse對應(yīng)的是數(shù)字0。
Python中字符串變量之間使用"+"號進(jìn)行字符串的拼接,使之生成新的字符串。字符變量可以和整數(shù)配合"*"號重復(fù)生成拼接相同的字符串。數(shù)字型變量和字符串之間不能進(jìn)行其他計算。
在Python中如果想獲取用戶鍵盤上輸入的信息,使用input函數(shù)即可。而讀取的信息 則是以字符串類型返回的。如:
字符串變量 = input("提示信息:")
下面我們來說說不同變量類型之間怎么進(jìn)行轉(zhuǎn)換。首先是int(x),將 x 轉(zhuǎn)換為一個整數(shù),float(x):將 x 轉(zhuǎn)換到一個浮點(diǎn)數(shù)。在 Python 中使用 print 函數(shù)將信息輸出到控制臺的時候,如果希望同時輸出文字和數(shù)據(jù)的時候。就需要使用格式化字符操作。%被稱為格式化操作符,類似于C語言,專門用于處理字符串中的格式。包含 % 的字符串,被稱為格式化字符串。%和不同的字符連用,不同類型的數(shù)據(jù)需要使用不同的格式化字符。下面單獨(dú)講講不同的結(jié)合方式及其含義。
文中介紹的字符串一個非常重要的知識點(diǎn):字符串格式化輸出。
格式化怎么理解?簡答來說:就是讓字符串按照我們設(shè)定的格式來輸出,達(dá)到我們想要的結(jié)果。主要是有4種方式:
格式化符號其實(shí)是為真實(shí)的值預(yù)留出一個空位,而且還可以控制顯示的格式。格式符包含一個類型碼,用來顯示不同的數(shù)據(jù)類型,比如字符串、二進(jìn)制、指數(shù)等。常見的不同的占位符如下:
關(guān)于對齊問題:
1. ^:居中對齊
2. >:右對齊
3. <:左對齊
4. +、-:顯示正負(fù)號
常用的語法形式為:%[(name)][flags][width].[precision] typecode
print("%9.3f" % 2.3)
2.300 # 前面4個空格
print("%+9.3f" % 2.3) # 帶上+符號輸出,9表示寬度,3表示小數(shù)位
+2.300
print("%-9.3f" % 2.3) # -表示左對齊輸出
2.300
print("%-9.3f" % -2.3)
-2.300
# 我們顯示聲明3個變量
name = "Yule Cottage" # 字符串類型
age = 25 # 整數(shù)類型
height = 1.76 # 浮點(diǎn)數(shù)類型
# 1、浮點(diǎn)數(shù)默認(rèn)是6位小數(shù)
# 2、%f和%F相同
print("我是:%s,年齡: %d,身高是:%f" % (name,age,height))
我是:Yule Cottage,年齡: 25,身高是:1.760000
# 指定浮點(diǎn)數(shù)的小數(shù)位
print("我是:%s,年齡: %d,身高是:%.3f" % (name,age,height))
我是:Yule Cottage,年齡: 25,身高是:1.760
下面的代碼是通過字典對的形式來傳入不同的數(shù)據(jù)類型,字典(后面會介紹python的字典)的值就是待格式的內(nèi)容。
需要注意的是name、age、height必須寫在%號的后面
print("我是:%(name)s,年齡: %(age)d,身高是:%(height).3f" % {"name":name,"age":age,"height":height})
我是:Yule Cottage,年齡: 25,身高是:1.760
print("八進(jìn)制:%o,十進(jìn)制:%i,十六進(jìn)制:%x" %(age,age,age))
八進(jìn)制:31,十進(jìn)制:25,十六進(jìn)制:19
# print("二進(jìn)制:%b" %(age)) # 二進(jìn)制不能使用
bin(age) # 通過bin函數(shù)查看
'0b11001'
number = 1.23456789
# 寬度為10,保留小數(shù)點(diǎn)后4位,默認(rèn)是右對齊
print("%10.4f" % number)
1.2346
print("%-10.4f" % number) # -符號表示左對齊,顯示4位小數(shù)
1.2346
# 右對齊,保留10位小數(shù),不足的用0補(bǔ)齊
print("%10.10f" % number)
1.2345678900
print("%-10.8f" % number) # 左對齊,保留8位小數(shù)
1.23456789
# 左對齊,保留7位小數(shù),會自動地進(jìn)行四舍五入
print("%-10.7f" % number)
1.2345679
下面是針對字符串的寬度等輸出設(shè)置:
name
'Yule Cottage'
print("%.10s" % name) # 9個字母+一個空格:左對齊
Yule Cotta
print("%.15s" % name) # 如果位數(shù)不夠,直接全部輸出
Yule Cottage
print("%10.6s" % name) # 右對齊,取出6個字符
Yule C
解釋:總長度為10,前面4個空格,加上4+一個空格+C
從python2.6+開始,新增了一種格式化字符串的函數(shù)str.format,可以說極大地增強(qiáng)了字符串格式化的功能,基本語法是通過{}和:來代替占位符%
{<參數(shù)序號>:<格式控制標(biāo)記>} ,中間有一個冒號,不能省略!!!
name = "Yule Cottage" # 字符串類型
age = 25 # 整數(shù)類型
height = 1.76 # 浮點(diǎn)數(shù)類型
sex = "男"
# 1、不設(shè)置位置
print("名字是:{},年齡是:{},身高是:{},性別:{}".format(name,age,height,sex))
名字是:Yule Cottage,年齡是:25,身高是:1.76,性別:男
# 2、設(shè)置位置參數(shù)
print("名字是:{0},年齡是:{1},身高是:{2},性別:{3}".format(name,age,height,sex))
名字是:Yule Cottage,年齡是:25,身高是:1.76,性別:男
# 設(shè)置位置參數(shù)
# 索引從0開始;2號位對應(yīng)的height
print("名字是:{0},身高是:{2},年齡是:{1},性別:{3}".format(name,age,height,sex))
名字是:Yule Cottage,身高是:1.76,年齡是:25,性別:男
print("性別:{3},身高是:{2},名字是:{0},年齡是:{1}".format(name,age,height,sex))
性別:男,身高是:1.76,名字是:Yule Cottage,年齡是:25
# 3、元組形式
# 使用*進(jìn)行解析
information = ("Peter",25)
print("姓名是:{},年齡是:{}".format(*information))
姓名是:Peter,年齡是:25
# 4、字典形式
# 參數(shù)為字典時候,通過**進(jìn)行解析配對
print("名字是:{name},年齡是:{age},身高是:{height},性別:{sex}".format(**{"name":name,"age":age,"height":height,"sex":sex}))
名字是:Yule Cottage,年齡是:25,身高是:1.76,性別:男
# 5、直接變量賦值
print("名字是:{name},年齡是:{age},身高是:{height},性別:{sex}".format(name="Yule Cottage",age="2歲",height="1.75m",sex="男"))
名字是:Yule Cottage,年齡是:2歲,身高是:1.75m,性別:男
寬度為20,我們實(shí)現(xiàn)居中、靠左、靠右對齊
name
'Yule Cottage'
print("{:^20s}".format(name)) # 居中
print("{:>20s}".format(name)) # 靠右
print("{:<20s}".format(name)) # 靠左
Yule Cottage
Yule Cottage
Yule Cottage
首先我們還是看看對齊問題,浮點(diǎn)數(shù)的對齊只保留6位小數(shù):
pi = 3.1415926
print("{:^20f}".format(pi)) # 居中 # 默認(rèn)只保留6位小數(shù)
print("{:>20f}".format(pi)) # 靠右
print("{:<20f}".format(pi)) # 靠左
3.141593
3.141593
3.141593
看看不同情況下的輸出格式,浮點(diǎn)數(shù)需要帶上小數(shù)點(diǎn),默認(rèn)全部是左對齊:
# 不同的輸出方式
print("{}".format(pi)) # 原數(shù)據(jù)
print("{:.2f}".format(pi)) # 2位小數(shù)
print("{:>.10f}".format(pi)) # 位數(shù)不足,右側(cè)補(bǔ)0
print("{:.4%}".format(pi)) # 百分比輸出
print("{:.2e}".format(pi))
3.1415926
3.14
3.1415926000
314.1593%
3.14e+00
sex
'男'
print("{0:30}".format(sex)) # 字符串默認(rèn)左對齊
print("{:>30}".format(sex)) # 改成右對齊
print("{0:30}".format(age)) # 數(shù)值類型默認(rèn)右對齊
print("{:<30}".format(height)) # 改成左對齊
男
男
25
1.76
# 指定填充的字符
print("{:*>30}".format(sex)) # *
print("{:+>30}".format(sex)) # +
print("{:+^30}".format(sex)) # 居中后填充+
print("{:+<30}".format(height)) # +
*****************************男
+++++++++++++++++++++++++++++男
++++++++++++++男+++++++++++++++
1.76++++++++++++++++++++++++++
主要是用來顯示數(shù)字的千位分隔符,在貨幣金額中使用的比較多:
b = 1003005000600
print("{:-^20}".format(b)) # 不用逗號
print("{:-^20,}".format(b)) # 用逗號
---1003005000600----
-1,003,005,000,600--
# 小數(shù)的千位分隔符顯示
print("{0:-20,}".format(12567.98760)) # 不填充
print("{0:-^20,}".format(12567.98760)) # 居中+填充
print("{0:->20,}".format(12567.98760)) # 右對齊+填充
print("{0:-<20,}".format(12567.98760)) # 左對齊+填充
12,567.9876
----12,567.9876-----
---------12,567.9876
12,567.9876---------
精度輸出的時候前面必須有一個小數(shù)點(diǎn)開頭,具有兩層含義:
pi
3.1415926
"{:.3f}".format(pi)
'3.142'
"{:30.5f}".format(pi) # 小數(shù)點(diǎn)后5位,整體寬度30
' 3.14159'
"{:*^30.5f}".format(pi) # 小數(shù)點(diǎn)后5位,寬度30,居中后補(bǔ)充*
'***********3.14159************'
name
'Yule Cottage'
"{:.4}".format(name) # 最大長度為4
'Yule'
"{:.6}".format(name) # 輸出最大長度為6
'Yule C'
表示輸出整數(shù)和浮點(diǎn)數(shù)類型的格式規(guī)則。對于整數(shù)類型,輸出格式包括6 種:
下面的例子表示的是365的二進(jìn)制、Unicode字符、十進(jìn)制、小寫16進(jìn)制和大寫的16進(jìn)制的不同輸出格式:
"{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(365)
'101101101,?,365,555,16d,16D'
如果是浮點(diǎn)數(shù)類型,那么輸出格式包括4種:
浮點(diǎn)數(shù)輸出時盡量使用<.精度>表示小數(shù)部分的寬度,有助于更好控制輸出格式。
"{0:e},{0:E}".format(3.1415)
'3.141500e+00,3.141500E+00'
"{0:f},{0:F}".format(3.1415)
'3.141500,3.141500'
"{0:%}".format(3.1415) # 保留6位小數(shù),百分比輸出
'314.150000%'
"{0:.2%}".format(3.1415) # 2位小數(shù),百分比輸出
'314.15%'
f-string是python3.6開始引入的新字符串格式化方法。其實(shí)它的方法很多和format是類似的,下面通過具體的例子來講解。
首先我們看一個簡單的例子,說明f-string如何使用:
a = "hello"
b = "python"
f"{a} {b}"
'hello python'
# 我們顯示聲明3個變量
name = "Yule Cottage" # 字符串類型
age = 25 # 整數(shù)類型
height = 1.76 # 浮點(diǎn)數(shù)類型
f'名字是:{name},年齡是:{age},身高是:{height}' # 前面加上f
'名字是:Yule Cottage,年齡是:25,身高是:1.76'
我們和format進(jìn)行一下對比:
"名字是:{},年齡是:{},身高是:{}".format(name,age,height) # format函數(shù)在最后面
'名字是:Yule Cottage,年齡是:25,身高是:1.76'
如果后面的string部分是表達(dá)式,也可以進(jìn)行格式化
f'{1+2+3}'
'6'
f'{1*2*3*4}'
'24'
對表達(dá)式進(jìn)行變量的賦值再格式化:
x = 100
y = 50
f"{x*y + x/y}" # 100*50 + 100 / 50 結(jié)果是浮點(diǎn)數(shù)
'5002.0'
上面的例子是直接賦值再通過表達(dá)式來格式化,我們其實(shí)可以將上面的表達(dá)式改成函數(shù),傳入?yún)?shù)來格式化,函數(shù)可以是:
# 自帶函數(shù)
print(f'my name is: {name}') # 原數(shù)據(jù)
print(f'my name is: {name.upper()}') # 全部變成大寫字母
my name is: Yule Cottage
my name is: YULE COTTAGE
# 自己寫個函數(shù)
def test(a,b):
return a * b + a / b
f'{test(100,50)}'
'5002.0'
# 或者直接寫成lambda 匿名函數(shù)
f'執(zhí)行的結(jié)果是:{(lambda x,y: x*y + x/y)(100,50)}'
'執(zhí)行的結(jié)果是:5002.0'
print(f'{name}') # 字符串默認(rèn)左
print(f'{name:>20.10s}') # > 右對齊 長度20 字符串最大長度10
print(f'{name:<20.12s}') # < 左對齊 長度20 字符串最大長度12
Yule Cottage
Yule Cotta
Yule Cottage
pi = 3.1415926
print(f'{pi}') # 原數(shù)據(jù)
print(f'{pi:^10.4f}') # 居中 長度為10 保留4位小數(shù)
print(f'{pi:>10.4f}') # 靠右 長度為10 保留4位小數(shù)
print(f'{pi:<10.4f}') # 靠左 長度為10 保留3位小數(shù)
3.1415926
3.1416
3.1416
3.1416
print(f'{pi}') # 原數(shù)據(jù)
print(f'{pi:*^10.4f}') # 填充*:居中 長度為10 保留4位小數(shù)
print(f'{pi:*>10.4f}') # 填充*:靠右 長度為10 保留4位小數(shù)
print(f'{pi:*<10.4f}') # 填充*:靠左 長度為10 保留3位小數(shù)
3.1415926
**3.1416**
****3.1416
3.1416****
和format中的千位分隔符相同,主要是用于金融貨幣中,自帶金錢屬性呀。可以使用逗號或者其他符號,常用逗號:
money = 1234567890
print(f'{money:,f}') # 輸出保留6位小數(shù)
1,234,567,890.000000
print(f'{money:_f}') # 使用下滑線
1_234_567_890.000000
string.Template是將一個string設(shè)置為模板,通過替換變量的方法,最終得到想要的string
from string import Template # 導(dǎo)入模板
template_string = '$name is $sex'
s = Template('$name is $sex')
s.substitute(name="Peter",sex="male")
'Peter is male'
from string import Template # 導(dǎo)入模板
template_string = '$name is $sex' # 1、設(shè)置模板
s = Template(template_string)
dic = {"name":"Peter","sex":"male"}
s.substitute(dic)
'Peter is male'
在上面的例子中:
from string import Template
class MyTemplate(Template):
delimiter = '%'
...
s = MyTemplate('%who knows?') # 改變符號
s.substitute(who='Peter')
'Peter knows?'
整理下關(guān)于對齊、精度、數(shù)值類型的符號等知識點(diǎn):
1、%占位符
表達(dá)式比較直觀,容易上手;但是當(dāng)參數(shù)變多的時候,格式就變得繁瑣,這種方式現(xiàn)在幾乎淘汰
2、format函數(shù)
方法比較靈活,能夠自己設(shè)置參數(shù)來對應(yīng)相應(yīng)的變量;參數(shù)變多的時候,表達(dá)式同樣繁瑣,整個式子會非常長
3、f-string
相對前兩種方式會靈活些,也更直觀。Python3.6開始出現(xiàn),語句格式可能稍顯復(fù)雜
重點(diǎn)還是要掌握format函數(shù)和f-string
--END--
Python是動態(tài)類型語言。
變量不需要顯示聲明類型。根據(jù)變量引用的對象,Python解釋器自動確定數(shù)據(jù)類型。
使用\行連接符 ----> 一行比較長的程序分為多行,Python解釋器仍然解釋位同一行。
變量稱之為對象的引用。變量存儲的就是對象的地址。變量通過地址引用了"對象"。
變量位于:棧內(nèi)存
對象位于:堆內(nèi)存
開發(fā)中,我們通常約定俗成遵守如下規(guī)則:
類型 | 規(guī)則 | 例子 |
模塊和包名 | 全小寫字母,盡量簡單。若多個單詞之間用下劃線 | math, os, sys |
函數(shù)名 | 全小寫字母,多個單詞之間用下劃線隔開 | phone, my_name |
類名 | 首字母大寫,采用駝峰原則。多個單詞時,每個單詞第一個字母大寫,其余部分小寫 | MyPhone、MyClass、Phone |
常量名 | 全大寫字母,多個單詞使用下劃線隔開 | SPEED、MAX_SPEED |
變量名 = 變量值;
變量:'容器';
變量的規(guī)則:標(biāo)識符由字母、下劃線和數(shù)字組成,且數(shù)字不能開頭;嚴(yán)格區(qū)分大小寫;不能使用關(guān)鍵字;
變量名,函數(shù)名和文件名全小寫,使用下劃線連接;類名遵守大駝峰命名法;常量名全大寫。
變量的聲明和賦值:用于一個變量綁定一個對象上,格式:變量 = 表達(dá)式;
變量在使用前必須先被初始化(先被賦值)
a=123
del a
print(a)
鏈?zhǔn)劫x值用于同一個對象賦值給多個變量。
x = y = 123
系列數(shù)據(jù)賦值給對應(yīng)相同個數(shù)的變量(個數(shù)必須保持一致)
a,b,c=4,5,6 相當(dāng)于:a=4;b=5;c=6
# 使用系列解包賦值實(shí)現(xiàn)變量值互換
a,b=1,2
a,b=b,a # 變量值互換
print(a,b) # 2,1
>>> 12
12
>>> 0b101
5
>>> 0o19
SyntaxError: invalid syntax
>>> 0o10
8
>>> 0xff
255
>>> 0xf
15
>>> 0x10
16
>>> int("456")
456
>>> int("456abc")
Traceback (most recent call last):
File "", line 1, in <module>
int("456abc")
ValueError: invalid literal for int() with base 10: '456abc'
>>> int("456.78")
Traceback (most recent call last):
File "", line 1, in <module>
int("456.78")
ValueError: invalid literal for int() with base 10: '456.78'
>>>
整數(shù)和浮點(diǎn)數(shù)混合運(yùn)算時,表達(dá)式結(jié)果自動轉(zhuǎn)型成浮點(diǎn)數(shù)。比如:2+8.0的結(jié)果是10.0
運(yùn)算符+、-、*,/、//、**和%和賦值符=結(jié)合可以構(gòu)成“增強(qiáng)型賦值運(yùn)算符”。
運(yùn)算符 | 例子 | 等價 |
+= | a += 2 | a = a + 2 |
-= | a -= 2 | a = a-2 |
*= | a *= 2 | a = a * 2 |
/= | a /= 2 | a = a / 2 |
//= | a //= 2 | a = a//2 |
**= | a **= 2 | a = a**2 |
%= | a %= 2 | a = a % 2 |
復(fù)合賦值可以讓程序更加精煉,提高效率。
運(yùn)算符 | 描述 | 示例 | 等價于 |
+= | 加法賦值字符串拼接 | sum += na += “sss” | sum = sum + na = a + “sss” |
-= | 減法賦值 | num -= n | num = num - n |
*= | 乘法賦值 | a *= b | a = a * b |
/= | 浮點(diǎn)除賦值 | a/=b | a = a / b |
//= | 整數(shù)除賦值 | a//=b | a = a//b |
%= | 取余賦值 | a%=b | a = a % b |
**= | 冪運(yùn)算賦值 | a**=2 | a = a**2 |
<<= | 左移賦值 | a<<=2 | a = a<<2 |
>>= | 右移賦值 | a>>=2 | a = a>>2 |
&= | 按位與賦值 | a&=b | a = a&b |
|= | 按位或賦值 | a|=b | a=a|b |
^= | 按位異或賦值 | a^=b | a = a^b |
??與C和JAVA不一樣,Python不支持自增(++)和自減(--)
import time
b = int(time.time())
totalMinutes = b//60
totalHours = totalMinutes//60
totalDays = totalHours//24
totalYears = totalDays//365 #忽略閏年情況
True和False定義成了關(guān)鍵字,其實(shí)本質(zhì)還是1和0,可以可數(shù)字相加。
在Python語言底層,會將布爾值True看作1,將布爾值False看作0,盡管從表面上看,True和1、False和0是完全不同的兩個值,但實(shí)際上,它們是相同的。
在Python語言中有一些特殊的布爾類型值為False,例如False、0、0.0、空值None、空序列對象(空列表、空元祖、空集合、空字典、空字符串)、空range對象、空迭代對象。其他情況,均為True。
a = True
b = 3
c = a+b #c的值是:4
print(c)
print('空字符串的布爾類型的值:',bool("")) #False
print('空列表布爾類型的值:',bool([])) #False
print('None布爾類型的值:',bool(None)) #False
print('0布爾類型的值:',bool(0)) #False
print('字符串True和False轉(zhuǎn)成布爾都是True:',bool("False")) #True
單引號和雙引號為了交叉使用;
'''''' 三引號保留格式的輸入;
+ 字符串之間的拼接
阻塞型函數(shù);
都會被封裝成str.
int('1234')
如果數(shù)字是字符串類型,轉(zhuǎn)int會報錯。
a = '9.9'
int(a)
float('12.34')
str(1234)
flag = False
int(flag) # 0
float(flag) # 0.0
str(flag) # 'False'
a = 2
bool(a) # True
a = 1
bool(a) # True
a = 0
bool(a) # False
a = ''
bool(a) # False
Python支持整數(shù)(如:50,520)和浮點(diǎn)數(shù)(如:3.14,10.0, 1.23e2),我們可以對數(shù)字做如下運(yùn)算。
運(yùn)算符 | 說明 | 示例 | 結(jié)果 |
+ | 加法 | 3+2 | 5 |
- | 減法 | 30-5 | 25 |
* | 乘法 | 3*6 | 18 |
/ | 浮點(diǎn)數(shù)除法 | 8/2 | 4.0 |
// | 整數(shù)除法 | 7//2 | 3 |
% | 模(取余) | 7%4 | 3 |
** | 冪 | 2**3 | 8 |
# 使用divmod()函數(shù)同時得到商和余數(shù)
divmod(13,3) # (4,1) 返回一個元組
c = 3
c / 2 # 除法
c // 2 # 整除
2 ** 3 # 2的3次方
3 % 2 # 取模 取余
number = int(input("請輸入一個3位整數(shù):"))
print('個位數(shù):', number % 10)
print('十位數(shù):', number // 10 % 10)
print('百位數(shù):', number // 100)
按位運(yùn)算符是把數(shù)字看作二進(jìn)制來進(jìn)行計算的。Python中的按位運(yùn)算法則如表所示。
運(yùn)算符 | 描述 |
& | 按位與運(yùn)算符:參與運(yùn)算的兩個值,如果兩個相應(yīng)位都為1,則該位的結(jié)果為1,否則0 |
| | 按位或運(yùn)算符:只要對應(yīng)的二個二進(jìn)位有一個為1時,結(jié)果為就為1. |
^ | 按位異或運(yùn)算符:當(dāng)兩對應(yīng)的二進(jìn)制位相異時,結(jié)果為1 |
~ | 按位取反運(yùn)算符:對數(shù)據(jù)的每個二進(jìn)制取反,既把1變?yōu)?,把0變?yōu)?,~x類似于-x-1 |
<< | 左移動運(yùn)算符:運(yùn)算數(shù)的每個二進(jìn)位全部左移若干位,由”<<”右邊的數(shù)據(jù)指定移動的位數(shù),高位丟棄,低位補(bǔ)0 |
>> | 右移動運(yùn)算符:把”>>”左邊運(yùn)算數(shù)的每個二進(jìn)制位全部右移若干位,”>>”右邊的數(shù)指定移動的位數(shù) |
a = 0b11001
b = 0b01000
print(bin(a|b)) #bin()可以將數(shù)字轉(zhuǎn)成二進(jìn)制表示 '0b11001'
print(bin(a&b)) #與
print(bin(a^b)) #異或
print(3<<2) #左移1位相當(dāng)于乘以2.左移兩位相當(dāng)于:3*4
print(20>>1) #右移移位相當(dāng)于除以2
所有比較運(yùn)算符返回1表示真,返回0表示假。這分別與特殊變量True和False等價。
以下假設(shè)變量a為15,變量b為30:
運(yùn)算符 | 描述 | 實(shí)例 |
== | 等于 - 比較對象的值是否相等 | (a == b) 返回 False。 |
!= | 不等于 - 比較兩個對象的值是否不相等 | (a != b) 返回 true. |
> | 大于 - 返回x是否大于y | (a > b) 返回 False。 |
< | 小于 - 返回x是否小于y。 | (a < b) 返回 true。 |
>= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 |
<= | 小于等于 - 返回x是否小于等于y。 | (a <= b) 返回 true。 |
a = 4
print(a<=30)
#關(guān)系運(yùn)算符可以連用
if(3<a<10):
print("a在3和10之間")
運(yùn)算符 | 格式 | 說明 |
or 邏輯或 | x or y | x為true,則不計算y,直接返回true;x為false,則返回y |
and 邏輯與 | x and y | x為true,則返回y的值x為false,則不計算y,直接返回false |
not 邏輯非 | not x | x為true,返回false;x為false,返回true |
#測試邏輯運(yùn)算符
a,b,c=10,20,30
print((a<b) and (b<c)) #and并且 輸出結(jié)果是True
print((a>b) or (b>c)) #or或者 輸出結(jié)果是False
print(not(b<c)) #not非 輸出結(jié)果是False
同一運(yùn)算符用于比較兩個對象的存儲單元,實(shí)際比較的是對象的地址。
運(yùn)算符 | 描述 |
is | is是判斷兩個標(biāo)識符是不是引用同一個對象 |
is not | is not 是判斷兩個標(biāo)識符是不是引用不同對象 |
is 與 == 區(qū)別:
is 用于判斷兩個變量引用對象是否為同一個,既比較對象的地址。
== 用于判斷引用變量引用對象的值是否相等,默認(rèn)調(diào)用對象的 __eq__()方法。
a=20
b=20
c=30
print("a和b是同一個對象",a is b) #執(zhí)行結(jié)果:True
print("a和c是同一個對象",a is c) #執(zhí)行結(jié)果False
print("a和c不是同一個對象",a is not c) #執(zhí)行結(jié)果True
成員運(yùn)算符測試實(shí)例中包含了一系列的成員,包括字符串,列表或元組。
運(yùn)算符 | 描述 |
in | 如果在指定的序列中找到值返回 True,否則返回 False |
not in | 不在,則返回True |
a = "python"
b = "py"
print(b in a) #True
c = [10,20,30]
print(10 not in c) #False
復(fù)雜的表達(dá)式一定要使用小括號;
乘除優(yōu)先加減;
位運(yùn)算和算術(shù)運(yùn)算>比較運(yùn)算符>賦值運(yùn)算符>邏輯運(yùn)算符
運(yùn)算符 | 說明 |
and , or , not | 布爾與、布爾或、布爾非 |
is , is not | 同一性判斷,判斷是否為同一個對象 |
in , not in | 判斷是否在指定序列中 |
<,<=,>,>=,!=,== | 比較值是否相當(dāng),可以連用 |
| ^ & | 按位或,按位異或、按位與 |
<<, >> | 移位 |
~ | 按位翻轉(zhuǎn) |
+,-,*,/,//,% | 加,減,乘,浮點(diǎn)除、整數(shù)除、取余 |
** | 冪運(yùn)算 |
*請認(rèn)真填寫需求信息,我們會在24小時內(nèi)與您取得聯(lián)系。