Python【第二篇】運算符及優先級、數據類型及經常使用操做、深淺拷貝

時間  2019-11-07
標籤 python 第二篇 運算符 優先級 數據 類型 經常 使用 深淺 拷貝 欄目 Python 简体版
原文   原文鏈接

1、運算符及優先級

Python 運算符（算術運算、比較運算、賦值運算、邏輯運算、成員運算）python

1.算數運算符

運算符api

描述app

實例，a=20，b=10ssh

+函數

加學習

a+b輸出結果30測試

-優化

減this

a-b輸出結果10spa

*

乘

a*b 輸出結果200

/

除

a/b輸出結果2

%

取模

a/b輸出結果0

**

取冪

a**b輸出結果20的10次方

//

取整除

9/2輸出結果4，9.0/2.0輸出結果4.0

2.比較運算符

運算符

描述

實例

==

等於

(a==b)返回False

!+

不等於

(a!=b)返回True

<>

不等於

(a<>b)返回True #3.x測試錯誤

>

大於

(a>b)返回True

>=

大於等於

(a>=b)返回True

<

小於

(a<b)返回False

<=

小於等於

(a<=b)返回False

3.賦值運算符

運算符

描述

實例

=

簡單的賦值運算符

c=a+b，將a+b的運算結果賦值給c（30）

+=

加法賦值運算符

c+=a 等效於c=c+a

-=

減法賦值運算符

c-=a 等效於c=c-a

*=

乘法賦值運算符

c*=a 等效於c=c*a

/=

除法賦值運算符

c/=a 等效於c=c/a

%=

取模賦值運算符

c%=a 等效於c=c%a

**=

取冪賦值運算符

c**=a 等效於c=c**a

//=

取整除賦值運算符

c//=a 等效於c=c//a

4.邏輯運算符

運算符

描述

實例

and

布爾「與」

(a and b)返回True

or

布爾「或」

(a or b)返回True

not

布爾「非」

not(a and b)返回False

 5.成員運算符

運算符

描述

實例

in

若是再指定的序列中找到值，返回True，不然返回False

x在y序列中，若是x在y序列中返回True

not in

若是再指定的序列中找不到值，返回True，不然返回False

x在y序列中，若是x在y序列中返回False

 

a="abcdefg"
b="b"
if b in a :
    print("b元素在a字符串中")
else:
    print("b元素不在a字符串")

6.位運算符

運算符

描述

實例 a=00001010 b=00010100

&

按位與運算符

(a&b)輸出結果0

|

按位或運算符

(a|b)輸出結果30

^

按位異或運算符

(a^b)輸出結果30

~

按位取反運算符

~10輸出結果-11

<<

左移運算符

a<<2輸出結果40

>>

右移運算符

a>>2輸出結果2

7.身份運算符

運算符

描述

實例

is

is是判斷兩個標識符是否是引用自一個對象

x is y,若是id(x)等於id(y)，is返回結果1

is not

is not是判斷兩個標識符是否是引用不一樣對象

x is not y,若是id(x)不等於id(y)，is not返回1

8.三目運算符

三目運算符能夠簡化條件語句的縮寫，可使代碼看起來更加簡潔，三目能夠簡單的理解爲有三個變量，它的形式是這樣的 name= k1 if 條件 else k2 ，若是條件成立，則 name=k1，不然name=k2，下面從代碼裏面來加深一下理解，從下面的代碼明顯能夠看出三目運算符可使代碼更加簡潔。

a=1
b=2
if a<b:                     #通常條件語句的寫法
    k=a
else:
    k=b
     
k=a if a<b else b      　　 #三目運算符的寫法 

9.運算符優先級

2、數據類型及經常使用操做（數字, bool, str, list, tuple, dict, set）

數據類型：數字、字符串、布爾值、字符串、列表、元組、字典、集合

序列：字符串、列表、元組

散列：集合、字典

查看不一樣數據類型的方法，dir（），列如：dir(list) 

>>> dir(list) ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'] 

一、數字

int

Python能夠處理任意大小的正負整數，可是實際中跟咱們計算機的內存有關，

在32位機器上，整數的位數爲32位，取值範圍爲-2**31～2**31-1，即-2147483648～2147483647

在64位系統上，整數的位數爲64位，取值範圍爲-2**63～2**63-1，即-9223372036854775808～9223372036854775807。

long

跟C語言不一樣，Python的長整數沒有指定位寬，即：Python沒有限制長整數數值的大小，但實際上因爲機器內存有限，咱們使用的長整數數值不可能無限大。
注意，自從Python2.2起，若是整數發生溢出，Python會自動將整數數據轉換爲長整數，因此現在在長整數數據後面不加字母L也不會致使嚴重後果了。

注意：在Python3裏再也不有long類型了，全都是int。

py2中

py3中

float

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

二、布爾值（bool）

布爾類型很簡單，就兩個值 ，一個True(真)，一個False(假),，主要用記邏輯判斷
也能夠將bool值歸類爲數字，是由於咱們也習慣用1表示True，0表示False

class  bool([ x])

    Return a Boolean value, i.e. one of True or False. x is converted using the standard truth testing procedure. If x is false or omitted, this returns False; otherwise it returns True. The bool class is a subclass of int (see Numeric Types — int, float, complex). It cannot be subclassed further. Its only instances are False and True (see Boolean Values).

# 參數若是缺省，則返回False
print(bool()) # False

# 傳入布爾類型時，按原值返回
print(bool(True)) # True
print(bool(False)) # False

# 傳入字符串時，空字符串返回False，不然返回True
print(bool('')) # False
print(bool('0')) # True

# 傳入數值時，0值返回False，不然返回True
print(bool(0)) # False
print(bool(0,)) # False
print(bool(1)) # True

# 傳入元組、列表、字典等對象時，元素個數爲空返回False，不然返回True
print(bool(())) # False
print(bool((0,))) # True
print(bool([])) # False
print(bool([0])) # True
print(bool({})) # False
print(bool({'name':'jack'})) # True

三、字符串（str）

字符串特性：有序、不可變

在Python中，加了引號的字符都被認爲是字符串！
那單引號、雙引號、多引號有什麼區別呢？ 單雙引號木有任何區別，只有下面這種狀況 你須要考慮單雙的配合

msg = "My name is jack, I'm 22 years old!"

多引號什麼做用呢？做用就是多行字符串必須用多引號

msg = '''
我在學python，
python功能很強大，
你是否要一塊兒學習呢？
'''
print(msg)

 經常使用操做 

s="abcdef ghg k"
print(s.title())              #將字符串轉換成標題，輸出 Abcdef Ghg K
 
print(s.capitalize())         #將字符串首字母大寫，輸出 Abcdef ghg k
 
print(s.count('d',0,len(s)))  #計算出子串 'd'在母串中出現的次數，默認是在整個母串中查找，
　　　　　　　　　　　　　　　　　 #能夠在後面跟兩個參數指定起始位置查找，這裏我指定了在（0，len（s））中查找，
　　　　　　　　　　　　　　　　　 #其中len（s）表明獲取字符串長度
 
print(s.startswith('a'))      #判斷字符串是否以什麼開頭，這裏輸出True,
 
print(s.find('g',0,len(s)))   #查找子串第一次在母串中出現的位置，這裏輸出7，一樣能夠本身指定位置範圍來搜查
 
print(s.upper())              #將字符串轉換成大寫，這裏輸出ABCDEF GHG K
 
print(s.join(['a','b','c']))  #用字符串 s 來鏈接列表['a','b','c'] 輸出 aabcdef ghg kbabcdef ghg kc
 
print(s.strip()) 　　　　　　　 #移除兩側空格
 
print(s.split()) 　　　　　　　 #分割字符串，返回一個列表 這裏輸出['abcdef', 'ghg', 'k']
 
print(s.replace('g','G',1))   #替換，默認所有替換，能夠設置爲1，只替換一次，這裏只替換一次輸出abcdef Ghg k
 
print(s[0:4])                 #切片，[0:4]表明將字符串s的前面4位取出來，這裏輸出 abcd

四、空值（None）

空值是Python裏一個特殊的值，用None表示。None不能理解爲0，由於0是有意義的，而None是一個特殊的空值。  

五、列表（list）

列表是Python內置的一種數據類型，是一種有序的集合，能夠聽任何數據類型，可對集合進行方便的增刪改查操做。

查看列表的方法，help(list)

 

更簡便看列表的方法：dir(列表)

  

l=['a','b','cc',4] 　　　　#定義一個列表
 
l.append(5) 　　　　　　　　#添加一個元素,l=['a', 'b', 'cc', 4, 5]
 
l.pop()　　　　　　　　　　　#從尾部刪除一個元素,l=['a', 'b', 'cc', 4]
 
l.remove('a') 　　　　 　　 #從列表中移除 'a',l=['b', 'cc', 4]
 
l.extend(['gg','kk']) 　　 #添加一個列表['gg','kk'], l=['b', 'cc', 4, 'gg', 'kk']
 
l.reverse() 　　　　　　　　 #反轉一個列表,l=['kk', 'gg', 4, 'cc', 'b']
 
print(l.count('kk'))  　　 #某元素出現的次數，輸出 1
 
print(l.index('gg'))  　　 #元素出現的位置，輸出 1
 
for i in l: 　　　　　　　　 #循環輸出列表元素
    print(i)
 
print(l[0:4:2]) 　　　　　　#列表切片，以步長2遞增，輸出['kk', 4]

六、元組（tuple）

不可修改，是隻讀列表

元組中不只能夠存放數字、字符串，還能夠存放更加複雜的數據類型
元組自己不可變，若是元組中還包含其餘可變元素，這些可變元素能夠改變

uple和list很是相似，可是tuple一旦初始化就不能修改，tuple也是有序的，tuple使用的是小括號標識。

t=('a','b','b','c') 　　#定義一個元組
 
print(t.index('b')) 　　#索引出元素第一次出現的位置，還能夠指定在某一範圍裏查找，這裏默認在整個元組裏查找輸出1
 
print(t.count('b')) 　　#計算元素出現的次數，這裏輸出2
 
print(len(t))　　　　　　#輸出遠組的長度，這裏輸出4
 
for i in t:
    print(i) 　　　　　　#循環打印出元組數據
 
print(t[1:3]) 　　　　　 #切片 輸出('b','b')

七、字典（dict）

字典是無序的，使用鍵-值（key-value）存儲，具備極快的查找速度。

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
 
d.get('Bob') 　　　　　　　　　　　　　　　　　　　　#根據key獲取values，若是不存在返回None，這裏輸出75
 
d.pop('Bob') 　　　　　　　　　　　　　　　　　　　　#根據鍵刪除某一元素 d={'Michael': 95, 'Tracy': 85}
 
d['Jason']=99       　　　　　　　　　　　　　　　　#新增元素 d={'Michael': 95, 'Tracy': 85, 'Jason': 99}
 
print(len(d))       　　　　　　　　　　　　　　　　#輸出字典長度，這裏輸出3
 
print('Jason' in d) 　　　　　　　　　　　　　　　　#python3 中移除了 has_key,要判斷鍵是否存在用in
 
for i in d:
    print(i)　　　　　　　　　　　　　　　　　　　　 #循環默認按鍵輸出
 
for i in d.values():　　　　　　　　　　　　　　　　#循環按值輸出
    print(i)
 
for k,v in d.items():　　　　　　　　　　　　　　　 #循環按鍵值輸出
    print(k,v)

八、集合（set）

set是一個無序（不支持索引和切片）並且不重複的集合，有些相似於數學中的集合，也能夠求交集，求並集等，下面從代碼裏來看一下set的用法，若是對這些用法不太熟悉的話，能夠照着下面的代碼敲一遍。

s1={1,2,3,1}                #定義一個set s1 若是s1={}爲空則默認定義一個字典
s2=set([2,5,6])             #定義一個set s2
print(s1)                   #s1={1,2,3} 自動去除重複的元素
 
s1.add(5)                   #s1={1,2,3,5} 添加一個元素
print(s1)
 
s3=s1.difference(s2)        #返回一個s1中存在而不存在於s2的字典s3，s3={1，3}，而s1並無改變
print(s3)
 
s1.difference_update(s2)    #s1跟新成上面的s3 s1={1，3}
s1.discard(1)               #刪除元素1，不存在的話不報錯  s1={3}
print(s1)
s1.remove(3)                #刪除元素3，不存在的話報錯    s1={}
print(s1)
s1.update([11,2,3])         #跟新s1中的元素，實際上是添加   s1={11,2,3}
print(s1)
k=s1.pop()                  #刪除一個元素，並將刪除的元素返回給一個變量，無序的，因此並不知道刪除誰
 
　　　　　　　　　　　　　　　　　　
s1={1,2,3,4}　　　　　　　　　　#這裏從新定義了集合s1，s2
s2={3,4,5,6}
r1=s1.intersection(s2)       #取交集，並將結果返回給一個新的集合 r1={3，4}
print(r1)
print(s1)
s1.intersection_update(s2)   #取交集，並將s1更新爲取交集後的結果 s1={3,4}
print(s1)
 
k1=s1.issubset(s2)           #s1是不是s2的的子序列是的話返回True，不然False 這裏k1=true
print(k1)
k2=s1.issuperset(s2)         #s1是不是s2的父序列 k2=False
 
k3=s2.isdisjoint(s1)         #s1,s2,是否有交集，有的話返回False,沒有的話返回True
print(k3)
s1.update([1,2])             #s1={1,2,3,4}
r3=s1.union(s2)              #取並集將結果返回給r3 r3={1,2,3,4,5,6}
print(r3)
r2=s1.symmetric_difference(s2)          #r2=s1並s2-s1交s2  r2={1,2,5,6}
print(r2)
s1.symmetric_difference_update(s2)      #s1更新爲 s1並s2 - s1交s2   s1={1,2,5,6}
print(s1)

3、深淺拷貝

淺拷貝會建立一個新的對象，只拷貝了原列表中嵌套列表的內存地址（裏面的嵌套列表與原列表指向同一個內存地址），嵌套列表中的內容改變了，因此就跟隨改變了；
對於不可變數據類型，深淺拷貝都只拷貝了引用，對於可變數據類型，深淺拷貝都會建立一個新的對象。

對於 數字 和 字符串 而言，賦值、淺拷貝和深拷貝無心義，由於其永遠指向同一個內存地址。

對於字典、元祖、列表 而言，進行賦值、淺拷貝和深拷貝時，其內存地址的變化是不一樣的。

賦值，只是建立一個變量，該變量指向原來內存地址

淺拷貝，在內存中只額外建立第一層數據

深拷貝，在內存中將全部的數據從新建立一份（排除最後一層，即：python內部對字符串和數字的優化） 

在python中，對象賦值其實是對象的引用。當建立一個對象，而後把它賦給另外一個變量的時候，python並無拷貝這個對象，而只是拷貝了這個對象的引用。

lia = [1,2,3,["a","b"]]

通常有三種方法：

（1）直接賦值，傳遞對象的引用而已，原始列表改變，被賦值的lib也會作相同的改變

lia = [1,2,3,["a","b"]]
lib = lia
print(id(lia), lia)
print(id(lib), lib)
lia.append(4)
print(id(lia), lia)
print(id(lib), lib)
lib.append(5)
print(id(lia), lia)
print(id(lib), lib)
lia[3].append('c')
print(id(lia), lia)
print(id(lib), lib)

（2）copy淺拷貝，沒有拷貝子對象，因此原始數據改變，子對象會改變

 

import copy
lia = [1,2,3,["a","b"]]
lib = copy.copy(lia)
print(id(lia), lia)
print(id(lib), lib)
lia.append(4)
print(id(lia), lia)
print(id(lib), lib)
lib.append(5)
print(id(lia), lia)
print(id(lib), lib)
lia[3].append('c')
print(id(lia), lia)
print(id(lib), lib)

（3）深拷貝，包含對象裏面的子對象的拷貝，因此原始對象的改變不會形成深拷貝里任何子元素的改變

import copy
lia = [1,2,3,["a","b"]]
lib = copy.deepcopy(lia)
print(id(lia), lia)
print(id(lib), lib)
lia.append(4)
print(id(lia), lia)
print(id(lib), lib)
lib.append(5)
print(id(lia), lia)
print(id(lib), lib)
lia[3].append('c')
print(id(lia), lia)
print(id(lib), lib)

4、練習（加Q羣獲取參考答案）

1.一個列表，找出只出現一次的元素。

2.列表 [11,22,33,44,55,66,77,88,99]，將全部大於 66 的值保存至字典的第一個key中，將小於 66 的值保存至第二個key的值中。即： {'k1': 大於66的全部值, 'k2': 小於66的全部值}

3.兩個列表，其中一個列表比另一個列表多一個元素，寫一個函數，返回這個元素

4.三級菜單

　　可依次選擇進入各子菜單

　　可從任意一層往回退到上一層

　　可從任意一層退出程序

 

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程