Python基礎01

時間 2019-11-16

標籤 python 基礎欄目 Python 简体版

原文原文鏈接

　　記得2015年剛上大學的時候，選的所有是計算機專業，因爲高考考得很差，考了一個普通二本院校，學得是計算機相關專業（網絡工程-物聯網方向）。現今即將大學畢業，大學期間，計算機的基礎知識都在校園裏面學過。第一門編程語言學的是C語言，即將去雙非學校去讀研究生，考得是學碩--計算機應用技術。我的對於大數據，人工智能，機器學習等方面比較感興趣，因此準備先進行Python的學習，找視頻學習一個全棧知識，知道學習週期很長，爲了之後的更好的服務於研究的方向，本身會加油努力。java

　　時間過得很快，人生可能也是如此。python

　　不將就，成爲更好的本身，爲社會多作點本身力所能及的事，也爲本身的追求。人活着，老是要有點氣節的，沒有靈魂地活着，和屍體有何區別！git

　　感謝幫助個人親人，朋友等，正是因爲大家在個人身邊，我纔會有一往無前的信心！web

　　謝謝！面試

寫在前面：編程

　　所用的開發環境：api

　　編程工具使用的是：Pycharm，具體的安裝，上網找一下，就會有相關的介紹，基本上就是「下一步」就能夠了，在這裏就不介紹了。數組

　　在文本編輯方面，我以爲Notepad++是分好用，推薦使用。網絡

主要知識點：app

Python的基礎知識：

1、Python的介紹

一、python的誕生

　　崇尚優美、清晰、簡單

　　2019年5月TIOBE編程語言排行榜單排行：

　　Python的主要應用領域：

　　雲計算：
       WEB開發：
       科學運算、人工智能
       系統運維
       金融
       圖形GUI

　　Python2.X與Python3.X的宏觀區別：

　　　　python2源碼不標準、混亂、重複代碼太多

　　　　python3統一標準，去除重複代碼。

　　Python發展史：

　　　　在宏觀上Python2.X與Python3.X的區別：

　　　　　　Python2.X源碼不標準、混亂、重複代碼多。

　　　　　　Python3.X統一標準、去除重複代碼。

　　　　　　　　　　2.7版本支持到2020年以後2版本就不會再進行更新

　　　　　　python 2.4版本————web框架Django誕生

　　　　　　python 3.0版本————2008年10月3

二、python是什麼編程語言

　　編譯型：一次性將全部程序編譯成二進制文件

　　　　缺點：出現bug從新再編譯，開發效率低，不能跨平臺；

　　　　優勢：運行速度快。

　　解釋型：程序執行，一行一行解釋

　　　　缺點：運行速度慢；

　　　　優勢：開發效率高，能夠平臺。

　　python是一種解釋型的強類型定義語言

三、python的優缺點

　　Python優勢：

　　　　優雅、明確、簡單

　　　　開發效率高：直接調用第三方庫

　　　　高級語言

　　　　可移植性

　　　　可擴展性

　　　　可嵌入式：能夠把Python嵌入C等語言中

　　Python的缺點：

　　　　運行速度慢（相比於編譯型）

　　　　總體代碼不能加密

　　　　線程不能利用多CPU

四、python的種類

    CPython：在C語言中能夠寫python，而後CPython將Python轉換成C的字節碼，再轉換爲0101。
   IPython
   JYPython：java平臺下的Python
   PYPY：將Python解釋型語言，一次性所有編譯成字節碼（解釋型），速度很快；等等

2、python的環境

　　Python環境的安裝教程，網上都有不少，這裏就不詳細描述。

　　使用的編輯器是集成開發環境，Pycharm

3、Python基礎初識

一、運行第一個Python代碼

　　按住win+R，而後輸入「cmd」回車

　　Python+空格+文件路徑

　Python2默認編碼方式是ASCII碼，不支持中文。Python3默認編碼方式是UTF-8，支持中文；

　　　　解決方法：在代碼最前面加上

# -*- encoding:utf-8 -*-

註解：在cmd命令行默認的編碼是gbk,因此不會報錯，可是會出現亂碼

執行下面代碼，會得出相應的Python優秀代碼書寫的指導原則。

import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
譯文：

　　優美勝於醜陋
　　顯式勝於隱式。
　　簡單勝於複雜。
　　複雜勝於難懂。
　　扁平勝於嵌套。
　　稀疏勝於緊密。
　　儘管實用性會戰勝純粹性，特例也不能凌駕於規則之上。
　　不要忽略任何錯誤，除非你確認要這麼作。
　　面對不明確的定義，拒絕猜想的誘惑。
　　找到一種最好惟一的一種方法去解決問題。
　　雖然一開始這種方法並非顯而易見，由於你不是Python之父。
　　作好過不作，但沒有思考的作還不如不作。
　　若是實現很難說明，那它是個壞想法。
　　若是實現容易解釋，那它有多是個好想法。
　　命名空間是個絕妙的想法，請多加利用。

二、變量

　　變量：就是將一些預算的中間結果存儲下來，以便後續的代碼使用。

　　變量命名規則：

　　　　一、必須由字母、數字、下劃線任意組合，且不能以數字開頭；

　　　　二、不能使用Python的關鍵字；

　　　　　　全部關鍵字：[and、elif、import、return、

　　　　　　　　　　　　as、else、in、try、assert、except、is、

　　　　　　　　　　　　while、break、finally、lambda、with、

　　　　　　　　　　　　class、for、not、yield、continue、from、

　　　　　　　　　　　　 or、def、global、pass、del、if、raise]

　　　　三、變量要具有實際的意思，經常使用駝峯體或者下劃線分割（推薦）。

　　　　四、不能是中文，中文不會報錯。

　　說明：

　　　　記住Python是解釋型語言（賦值先算等號右邊的）；

三、常量

　　常量：一直不變的量。（Python中沒有常量這個概念）

　　約定俗成搞一個常量，常量所有用大寫表示。

四、註釋

   方便本身，方便他人理解代碼
   單行註釋：#
   多行註釋：'''被註釋內容''' 或者是   """被註釋內容"""

五、用戶交互

　　樣例：

name = input('請輸入你的名字：')
age = input('請輸入你的年齡：')
print(name, age,type(age))
print('個人名字是'+name,'個人年齡'+age+'歲')

　　　一、等待輸入；
　　　　二、將你輸入的內容賦值給了前面的變量；
　　　　三、input出來的數據類型所有是str。

六、基礎數據類型

　　數字：int 12,3

　　　　判斷數據類型： type()
數字轉化成字符串str(int)
用int(str)進行字符串轉化的時候，字符串必須所有是數字組成的

print(100,type(100))
print('1000',type('1000'))

　　　　取值範圍:32位機。範圍爲-2^31-2**31-1
          64位機。範圍爲-2^63-2**63-1
          Python中沒有long的概念
　　　　能夠進行：+ - * /
          % 取餘
          **冪運算

　　字符串：str
　　　　Python中凡是用引號（單雙無所謂）引發來的都是字符串
   在字符串中有單引號的時候要注意包含關係。
   操做方法：
   　　　　字符串相加用 ‘+’ 能夠無縫拼接
   　　　　字符串能夠與數字相乘：str*int （重複多遍）
   　　　　三個引號引發來，（涉及到換行必須用三個引號）若是賦值給變量，就是一個大的字符串　　　　

msg = '''
牀前明月光，
疑是地上霜。
舉頭望明月，
低頭思故鄉。
'''
print(msg)

結果：打印出msg裏面的那首詩。

　　布爾值：
　　　　只有兩種狀態True和False；

　　　　在判斷的時候運用。

Python控制流

　　在Python中有三種控制流語句-- if、for和while。

七、if--條件判斷

　　if 條件：
　　　　if-塊

　　elif（可選）：

　　　　elif-塊

　　else（可選）：

　　　　else-塊

　　說明：經過縮進來展示結果塊，來進行格式控制
第一種：

if 5 > 4:
    print(6666)
    print(77777)

結果：6666 77777
第二種：

if 4 > 3:
    print('我請你喝酒')
else:
    print('喝什麼酒')

結果：我請你喝酒
多選：

num = input('請輸入您猜的數字：')
if num == '1':
    print('一塊兒抽菸')
elif num == '2':
    print('一塊兒喝酒')
elif num == '3':
    print('新開了一家，走看看')
else:
    print('你猜錯了...')

多個條件只走一個

num = int(input('請輸入您猜的數字：'))

if num == 1:
    print('一塊兒抽菸')
elif num == 2:
    print('一塊兒喝酒')
elif num == 3:
    print('新開了一家，走看看')
else:
    print('你猜錯了...')

if嵌套：

name = input('請輸入名字：')
age = input('請輸入年齡：')
if name == '小二':
    if age == '18':
        print(666)
    else:
        print(3333)
else:
    print('錯了....')

備註：不像C/C++,在Python中沒有switch語句，可是可使用if來進行實現

八、while--循環

當while後面的條件是真時，while中的循環體就會開始執行。

while True:
    print('咱們不同')
    print('在人間')
    print('癢')
print('2222')

結果：一直進行循環，能夠執行，不會報錯

#利用while循環實現從1到99的打印：

count = 1
flag = True
 
while flag:
    print(count)
    count = count + 1
    if count > 100:
        flag = False

count = 1
while count <= 100:
    print(count)
    count = count + 1

#用while循環實現從1加到100

sum = 0
count = 1

while count <= 100:
    sum = sum + count
    count = count + 1
print(sum)

固定搭配 while...else...

count = 0
while count <= 5:
    count += 1
    if count == 3:
     # 1   break
        pass
else:
    print("循環正常執行完啦")
print("-----out of while loop-----")

九、for--循環

for in是另一個循環語句，它通常用在一序列對象的迭代上，即逐一使用序列中的每一個項目。（序列會在後面的博客中介紹）

for i in range(1, 5):
    print(i)
else:
    print('The for loop is over')

這裏使用了內建函數range生成了一個序列，else部分是可選的，輸出結果：

1
2
3
4
The for loop is over

備註：Python中的for循環，相對於C/C++來講，確實簡單，不易出錯。

s = 'sdvvebr'
for i in s:     #s能夠是字符串，列表，元組，字典
    print(i)

十、break語句

無論while後面的判斷條件是真仍是假，只要運行到break語句就會終止該循環，多層循環嵌套，終止本層循環。

print('1111')
while True:
    print('2222')
    print('3333')
    break
    print('4444')
print('abcde')

運行結果：

1111
2222
3333
abcde

註解：參照結果，會發現，'4444' 沒有被打印出來，由於break語句終止了while循環。

#從1打印到100

count = 1
while True:
    print(count)
    count = count + 1
    if count > 100:break

十一、continue語句

continue語句被用來告訴Python跳過當前循環的剩餘語句，而後繼續進行下一輪循環。在while循環和for循環中均適用（結束本次循環，執行下一次循環）。

count = 0
while count <= 100:
    count +=1
    if count > 5 and count < 95:
        continue
    print("loop",count)    
print("------out of while loop-------")

運行結果：loop 1 ~ loop 100,最終打印 ------out of while loop-------

#使用continue語句打印1-20

print(111)
count = 1

while count <= 20:
    print (count)
    count = count + 1
    continue

註解：若是上面的代碼第6句和第7句進行了互換，就會出現一直打印1，不停歇。

十二、格式化輸出

Python中的格式化輸出就 % 和 format

（1）%佔位符（s表示字符串，d表示數字，%%只是單純的顯示百分號）

例如：

#% s d
name = input('請輸入姓名:')
age = input('請輸入年齡:')
height = input('請輸入身高:')
msg = "我叫%s，今年%s，身高%s" %(name,age,height)
print(msg)

註解：若是輸出的msg中有相關的須要用%來表示的要用兩個%（其中第一個%轉義）

樣例一

name = input("請輸入姓名：")
age = int(input("請輸入年齡："))
height = input("請輸入身高：")
msg = '''
========= info of %s =========
name:%s
age:%d
height:%s
============= end =============
''' %(name, name, age,height)
print(msg)

（2）format的三種樣式

s = '我叫{}，今年{}，愛好{}，再說一下我叫{}'.format('張三',36,'girl','喋血弒神')
print(s)
name = input("請輸入名字：")
s2 = '我叫{0}，今年{1}，愛好{2}，再說一下我叫{0}'.format(name,36,'girl')
print(s2)
name = input("請輸入名字：")
s3 = '我叫{name}，今年{age}，愛好{hobby}，再說一下我叫{name}'.format(name=name,age=36,hobby='girl')
print(s3)

1三、編碼

不管是電腦的傳輸還有儲存，都是0101001
   ASCII碼
       最開始設計7位，爲了之後的發展預留了1位，第一位是0
       8bit = 1Byte
       1024Byte = 1KB
       1024KB = 1MB
       1024MB = 1GB
       1024GB = 1TB
    因爲中文九萬多字，不可以知足國際的衆多語言的使用。
       美國爲了解決這個問題，提出了萬國碼（Unicode）
   最開始：
       1個字節能夠表示全部的英文和特殊字符
       2個字節，16位，65535，中文不夠。
           Unicode一箇中文用4個字節表示。
    Unicode太浪費空間-》升級utf-8，一箇中文用3個字節表示
       Python2默認使用ASCII碼，因此打印中文會報錯；
   gbk，國內使用，中國人本身建立的，只包含中文，一箇中文用2個字節表示

1四、運算符

運算符分爲三種：算數運算符，比較運算符，邏輯運算符

（1）算數運算符

　　+-*/ %（取餘） //（整除）

（2）比較運算符

　　> < >= <= ==（比較相等）！=（不等於）

（3）邏輯運算符

　　and or not（與，或，非）
　　優先級：

　　　　兩邊不等式：

　　　　　　　　() > not > and > or,同級自左向右

　　　　兩邊數字：　　　　

　　　　　　　　X or Y ,X 爲True，則返回X

　　　　　　　　X and Y ,X 爲True，則返回Y(and和or相反)

　　　　數字轉換成布爾值：

　　　　　　　　非零的轉換成布爾值是True，零轉換成布爾值是False

　　　　布爾值轉換成數字：

　　　　　　　　True轉換成數字是1，False轉換成數字是0

1五、數據類型

（1）int：相似於1，2，3這樣的，主要用於計算

主要的方法：

　　bit_length():將int類型的數據轉換成二進制的最少位數

i = 7
print(i.bit_length())

結果：3，數字7轉化爲二進制是111，最少的二進制位數是3

（2）bool：True和False，主要用於判斷真假

（3）str：用引號引發來的都是字符串，主要是儲存少許數據，進行操做。

　　第一部分：str的索引和切片

　　　　　　str的索引第一位是從0開始的；

s = 'ABCDEFghijkl'
s1 = s[0]
print(s1)           #結果：A
s2 = s[2] 
print(s2)           #結果：C

　　　　　　str的切片，原來的字符串不變，顧頭不顧尾

s = 'ABCDEFghijkl'
s3 = s[0:4]
print(s3)    #結果：ABCD
s4 = s[-1]   #取最後一位，倒着數，從-1開始
print(s4)    #結果：l
s5 = s[-2]   #取最後一位
print(s5)    #結果：k
s6 = s[:]
s7 = s[0:]
print(s6,s7)   #結果：均全取
s9 = s[0:0]
print(s9)      #結果：空

　　　　　　切片，跳着取,加一個步長。默認是1。格式：s[首:尾:步長]，倒着取,就是負的，顧頭不顧尾

s = 'ABCDEFghijkl'
s10 = s[0:5:2]
print(s10)  #結果：ACE
s11 = s[3::-1] 
print(s11)  #結果：DCBA

　　第二部分：str的經常使用操做方法（產生新的字符串，不影響原來的字符串）

　　　　　　①capitalize()：只是首字母大寫

s = 'ABCDEFghijkl'
s1 = s.capitalize()
print(s1)            #結果：Abcdefghijkl

　　　　　　②upper()：字符串所有大寫

s = 'ABCDEFghijkl'
s2 = s.upper()
print(s2)            #結果：ABCDEFGHIJKL

　　　　　　③lower()；字符串所有變小寫

s = 'ABCDEFghijkl'
s3 = s.lower()
print(s3)            #結果：abcdefghijkl

　　　　　　④swapcase()：大小寫翻轉（大寫變小寫，小寫變大寫）

s = 'ABCDEFghijkl'
s3 = s.swapcase()
print(s3)            #結果：abcdefGHIJKL

　　　　　　⑤title()：每一個隔開的單詞首字母大寫(除了英文字母以外的全部都是特殊字符)

s = 'ABCDEF ghijkl'
s4 = s.title()
print(s4)             #結果：Abcdef Ghijkl

　　　　　　⑥center()：設定總寬度居中，默認空格填充，能夠作設置字符填充

s = 'ABCDEFghijkl'   
s5 = s.center(20,'#')
print(s5)            #結果：####ABCDEFghijkl####

　　　　　　⑦expandtabs()：總共八個字符，不足8位補空格

s = 'ABCDEF\tghijkl'
s6 = s.expandtabs()
print(s6)              #結果：ABCDEF  ghijkl
s = 'AB\tghijkl'
s6 = s.expandtabs()
print(s6)              #結果：AB      ghijkl

　　　　　　⑧replace()：替換

s = 'fegegwfegqhhii'
s11 = s.replace('e','王',1)  #默認所有替換，加數字表示替換多少處
print(s11)                   #結果：f王g王gwfegqhhii

　　　　　　⑨is系列

name = 'zhangsan123'
print(name.isalnum())     #結果：True，字符串由字母和數字組成
print(name.isalpha())     #結果：False，字符串只由字母組成
print(name.isdigit())     #結果：False，字符串只由數字組成

公共方法：

①len()：查看長度

s1 = 'nihao你好'
num = len(s1)
print(num)     #結果：7

②startwith()：判斷字符以什麼爲開頭

s = 'ABCDEFghijkl'
s7 = s.startswith('AB')
if s7:
    pass
elif s.startswith('bl'):
    pass
print(s7)                  #結果：True
s71 = s.startswith('e',2,5)# 從2到5是否以e爲開頭
print(s71)                 #結果：False

③endwith()：判斷字符以什麼爲結尾，方法和startwith()類似

④find()：返回位置索引,返回數字

#若是是總體返回第一個字符的索引，找不到返回-1
s = 'ABCDEFghijkl'
s8 = s.find('gh')
print(s8,type(s8))     #結果：6 <class 'int'>
s8 = s.find('CD')
print(s8,type(s8))     #結果：2 <class 'int'>

⑤index()：經過元素找索引，找不到報錯

s = 'ABCDEFghijkl'
s8 = s.find('A')
print(s8,type(s8))      #結果：0 <class 'int'>
s81 = s.index('Z')      #結果：報錯

⑥strip(), rstrip(), lstrip()：默認刪除先後空格，中間有空格不行

s = 'ABCDEF ghijkl'
s9 = s.strip()
print(s9)
username = input('請輸入姓名：').strip()
if username == '張三':  #可能隨手加空格
    print('恭喜發財！！！')
s = '#李 四$'
s91 = s.strip(' $#')  #只要出現的最小的單個元素就刪
print(s91)

⑦count()：計數，沒有爲0

s = 'AAAABCDEFghijkl'
s10 = s.count('A')
print(s10)               #結果：4

⑧split()：數據類型的轉換 str----》list，遇到分隔符一分爲二

s = ':ABC:def:GHI'
l = s.split(':')
print(l)#結果：['', 'ABC', 'def', 'GHI']

int，bool，str之間的轉換：

int ----> str，  沒有條件，直接用str(int)方法轉換；

int ----> bool， 只要是零就是False，非零爲True；

str ----> int， str只能是數字；

str -----> bool， 空字符串就是False，只要有數據就是True，哪怕是有一個空格都是True；

bool -----> int， True轉換成數字就是1，False轉換成數字就是0（ps:True 的效率比寫1效率低，例如：while 1：（由於要轉換成機器碼））。

（4）list：[1,2,3,'名字'，[1,2,3]，主要用於存儲大量的數據

（5）元組：（1,2,3，'姓名'），只能讀，可以存儲大量的數據

（6）字典：{'name'：'姓名'，‘age’：18}，主要存儲大量的關係型數據

（7）集合：{1,2,3,'abcd'}

1六、列表

列表是由一系列按照特定順序排列的元素，能夠在列表中加入任何東西，其中的元素之間沒有任何關係。

因爲列表中包含多個元素，因此通常給列表制定一個表示複數的名稱。

訪問列表中的元素（列表中元素的下標是從0開始的）

names = ['tom',[1,2,3],'Andy','egon','杰倫','sandy']
l1 = names[0]
print(l1)    #結果：tom
l2 = names[1]
print(l2)    #結果：[1, 2, 3]
l3 = names[0:3]    #取前面3個
print(l3)    #結果：['tom', [1, 2, 3], 'Andy']

增（3種）

append()：原列表進行增長

names = ['tom',[1,2,3],'Andy','egon','杰倫','sandy']
names.append('日天')
names.append(1)
print(names)　　#結果：['tom', [1, 2, 3], 'Andy', 'egon', '杰倫', 'sandy', '日天', 1]

insert()：插入

names = ['tom',[1,2,3],'Andy','egon','杰倫','sandy']
names.insert(5,'春哥')
print(names)　　#結果：['tom', [1, 2, 3], 'Andy', 'egon', '杰倫', '春哥', 'sandy']

extend()：分解成元素，添加元素

names = ['tom',[1,2,3],'Andy','egon','杰倫','sandy']
names.extend('二哥')
#names.extend(123) # int 是一個總體，不能迭代
names.extend([1,2,3])
print(names)　　　　#結果：['tom', [1, 2, 3], 'Andy', 'egon', '杰倫', 'sandy', '二', '哥', 1, 2, 3]

刪（4種）

pop()：按索引去刪除，返回值是要刪除的元素

names = ['tom',[1,2,3],'Andy','egon','杰倫','sandy']
names.pop(0)
print(names)　　#結果：[[1, 2, 3], 'Andy', 'egon', '杰倫', 'sandy']
names.pop()     # 默認刪除的是最後一個元素
print(names)　　#結果：[[1, 2, 3], 'Andy', 'egon', '杰倫']

remove()：按元素去刪除，沒有返回值

names = ['tom',[1,2,3],'Andy','egon','杰倫','sandy']
names.remove('egon')
print(names)　　#結果：['tom', [1, 2, 3], 'Andy', '杰倫', 'sandy']

clear()：清空列表

names = ['tom',[1,2,3],'Andy','egon','杰倫','sandy']
names.clear()
print(names)　　#結果：[]

del：刪除列表，而且能夠切片去刪

names = ['tom',[1,2,3],'Andy','egon','杰倫','sandy']
del names
print(names)   # 會報錯，由於已經沒有了names列表

names = ['tom',[1,2,3],'Andy','egon','杰倫','sandy']
del names[2:5]
print(names)　　#結果：['tom', [1, 2, 3], 'sandy']

改（2種）

找到對應的索引直接賦值就行

names = ['tom',[1,2,3],'Andy','egon','杰倫','sandy']
names[0] = '張三'
names[2] = [4, 5, 6]
print(names)　　#結果：['張三', [1, 2, 3], [4, 5, 6], 'egon', '杰倫', 'sandy']

切片修改，按照迭代去賦值，拆分填多少無所謂

names = ['tom',[1,2,3],'Andy','egon','杰倫','sandy']
names[0:2] = '李四'
print(names)　　#結果：['李', '四', 'Andy', 'egon', '杰倫', 'sandy']
names[0:2] = ['李四','春哥',1,2,3]
print(names)　　#結果：['李四', '春哥', 1, 2, 3, 'Andy', 'egon', '杰倫', 'sandy']

查

遍歷列表中的每個元素

names = ['tom',[1,2,3],'Andy','egon','杰倫','sandy']
for i in names:
    print(i)#結果：tom
                # [1, 2, 3]
                #Andy
                #egon

切片查找，查找出來仍是一個列表

names = ['tom',[1,2,3],'Andy','egon','杰倫','sandy']
print(names[0:2])　　#結果：['tom', [1, 2, 3]]

公共方法：

len()：長度

names = ['tom',[1,2,3],'Andy','egon','杰倫','sandy']
l = len(names)
print(l)　　#結果：6

count()：計數，返回整數

names = ['tom',[1,2,3],'Andy','egon','杰倫','sandy']
num = names.count('杰倫2')
print(num)　　#結果：1，沒有返回0

index()：找到元素的索引

names = ['tom',[1,2,3],'Andy','egon','杰倫','sandy']
print(names.index('Andy'))　　#結果：2，沒有該元素會報錯

sort()：排序，主要針對數字

#默認正序
li = [1,5,4,7,6,7,3]
li.sort()
print(li)　　#結果：[1, 3, 4, 5, 6, 7, 7]

#反序
li = [1, 5, 4, 7, 6, 7, 3]
li.sort(reverse=True)
print(li)　　#結果：[7, 7, 6, 5, 4, 3, 1]

reverse()：列表反轉

li = [1, 5, 4, 7, 6, 7, 3]
li.reverse()
print(li)　　#結果：[3, 7, 6, 7, 4, 5, 1]

列表的方法嵌套

infos = ['Andy', 'zhangsan', '李四', '王五', 'zhaoliu', ['name','age','89']]
print(infos[1][1])　　#結果：h
infos[1] = infos[1].capitalize()
print(infos)　　　　   #結果：['Andy', 'Zhangsan', '李四', '王五', 'zhaoliu', ['name', 'age', '89']]

infos = ['Andy', 'zhangsan', '李四', '王五', 'zhaoliu', ['name','age','89']]
infos[2] = 'lisi'
print(infos)　　　　　　#結果：['Andy', 'zhangsan', 'lisi', '王五', 'zhaoliu', ['name', 'age', '89']]

infos = ['Andy', 'zhangsan', '李四', '王五', 'zhaoliu', ['name','age','89']]
infos[2] = infos[2].replace('四','日天')
print(infos)　　　　　　#結果：['Andy', 'zhangsan', '李日天', '王五', 'zhaoliu', ['name', 'age', '89']]

將name全變成大寫

infos = ['Andy', 'zhangsan', '李四', '王五', 'zhaoliu', ['name','age','89']]
infos[-1][0] = infos[-1][0].upper()
print(infos)　　　　　　#結果：['Andy', 'zhangsan', '李四', '王五', 'zhaoliu', ['NAME', 'age', '89']]

1七、元組

元組又稱只讀（兒子不能改，孫子可能能夠改）列表可循環，可查詢，可切片

infos = (1,2,3,'zhangsan',[2,3,4,'lisi'],'Wangwu')
print(infos[3])    #結果：zhangsan,可查
print(infos[0:4])  #結果：(1, 2, 3, 'zhangsan'),可切片,切片以後仍是元組
for i in infos:    #結果：1
    print(i)            #2
                        #3
                        #zhangsan
                        #[2, 3, 4, 'lisi']
                        #Wangwu,可循環

把lisi改爲大寫（孫子可能能夠改），由於孫子有可能不是元組

infos = (1,2,3,'zhangsan',[2,3,4,'lisi'],'Wangwu')
infos[4][-1] = infos[4][-1].upper()
print(infos)　　　　#結果：(1, 2, 3, 'zhangsan', [2, 3, 4, 'LISI'], 'Wangwu')

append()：追加

infos = (1,2,3,'zhangsan',[2,3,4,'lisi'],'Wangwu')
infos[4].append('趙六')
print(infos)　　　　#結果：(1, 2, 3, 'zhangsan', [2, 3, 4, 'lisi', '趙六'], 'Wangwu')

join()：可迭代的對象

用法：‘用什麼分割（字符）’.join(可迭代對象)

s = 'zhangsan'
s1 = '+'.join(s)
print(s1)　　#結果：z+h+a+n+g+s+a+n

列表------》字符串用 join()

names = ['tom','Andy','egon','杰倫','sandy']
s = ''.join(names)
print(s)　　#結果：tomAndyegon杰倫sandy

字符串------》列表用 split()

range()，裏面加範圍，能夠當作是一個列表

print(type(range(1,100)))
for i in range(90,100):
    print(i)　　　　#結果：打印90-99
for i in range(90,100,3):
    print(i)　　　　#結果：打印90，93,96,99
for i in range(10,0,-1):
    print(i)　　　　#結果：打印10-1
for i in range(0,10,-1):    #不會報錯
    print(i)　　　　#結果：不顯示
for i in range(10, -1):  # 不會報錯
    print(i)　　　　#結果：不顯示
for i in range(10,-1,-1):  # 包括0
    print(i)　　　　#結果：10-0

變量總體的概念

a, b = [1, 2]
print(a, b)　　　　　　#結果：1 2
a, b = [1, 2], [2, 3]
print(a, b)　　　　　　#結果：[1, 2] [2, 3]
a, b = (3, 4)
print(a, b)　　　　　　#結果：3 4

a,b = 1,2　　
print(a,b)　　　　　　#結果：1 2
#面試題：一行代碼轉換ab的值
a,b=b,a
print(a,b)　　　　　　#結果：2 1

1八、字典

字典：惟一的映射類型，以鍵值對組成
　　　　dict 的 key 必須是不可變數據類型，可哈希
　　　　 value：任意數據類型
　　dict 優勢：二分查找去查詢
　　　　　　儲存大量的關係
　　特色：無序的（3.5之前的版本）
　　數據類型劃分：可變數據類型和不可變數據類型
　　　　不可變數據類型：
　　　　　　　　　　　　元組，bool值，int，str（對str的各類操做都會造成新的str），
　　　　　　　　　　　　不可更改又叫可哈希
　　　　可變數據類型：
　　　　　　　　　　　　列表list，字典dict，集合set
　　　　　　　　　　　　又叫不可哈希

字典的定義

dic = {
    'name': ['張三','李四'],              # str--->list
    'class': [{'num':71,'avg_age':18}],  # str--->list--->dict
    True: 1,                             # bool---->int
    (1, 2, 3): '無心義',                  # 元組--->str
    1: '大哥'                             # int--->str
}
print(dic)#結果：{'name': ['張三', '李四'], 'class': [{'num': 71, 'avg_age': 18}], True: '大哥', (1, 2, 3): '無心義'}

增（2種）

dic1 = {'age':18,'name':'zhang','sex':'male'}
dic1['high'] = 185  #沒有鍵值對添加
dic1['age'] = 16    #若是有鍵，則覆蓋
print(dic1)#結果：{'age': 16, 'name': 'zhang', 'sex': 'male', 'high': 185}

dic1 = {'age':18,'name':'zhang','sex':'male'}
dic1.setdefault('weight')       #默認是None
print(dic1)#結果：{'age': 16, 'name': 'zhang', 'sex': 'male', 'high': 185, 'weight': None}
dic1.setdefault('weight', 150)  #原來有鍵的話不覆蓋，沒有的話添加
print(dic1)#結果：{'age': 16, 'name': 'zhang', 'sex': 'male', 'high': 185, 'weight': None}

刪（4種）（儘可能用pop()）

①pop(),按鍵刪除

dic1 = {'age':18,'name':'zhang','sex':'male'}
print(dic1.pop('age'))  #有返回值，字典的鍵相似於列表的索引
print(dic1)                   #結果：18
# dic1.pop(dage')       # 若是沒有，會報錯
# print(dic1)                 #結果：{'name': 'zhang', 'sex': 'male'}
dic1.pop('dage',None)   # 不知道有沒有的狀況下，防止報錯
print(dic1)　　　　　　　　　　　 #結果：{'name': 'zhang', 'sex': 'male'}
print(dic1.pop('大哥','沒有此鍵'))    #結果：沒有此鍵；可寫一個提示，可設置返回值。若是有鍵則返回該鍵對應的值
print(dic1)   　　　　　　　　　　　　　#結果：{'name': 'zhang', 'sex': 'male'}

②popitem()，隨機刪除

dic1 = {'age':18,'name':'zhang','sex':'male'}
dic1.popitem()
print(dic1)             #結果：{'age': 18, 'name': 'zhang'}。隨機刪除，沒有意義，現今的版本通常默認刪除最後一個
print(dic1.popitem())   #結果：('name', 'zhang')；返回元組，刪除的鍵值

③clear()，清空字典

dic1 = {'age':18,'name':'zhang','sex':'male'}
dic1.clear()
print(dic1)             #結果：{}

④del，刪除鍵值，和整個字典

dic1 = {'age':18,'name':'zhang','sex':'male'}
del dic1['name']      # 有的話刪除，沒有的話報錯
print(dic1)           #結果：{'age': 18, 'sex': 'male'}
# del dic1['name1']
# print(dic1)
del dic1
print(dic1)           #結果：報錯，由於不存在dic1

改（在增的時候的覆蓋自己就是一種改）

dic1 = {'age':18,'name':'zhang','sex':'male'}
dic1['age'] = 16
print(dic1)#結果：{'age': 16, 'name': 'zhang', 'sex': 'male'}

update（）,對原字典進行覆蓋該更新

dic1 = {'age':18,'name':'zhang','sex':'male'}
dic2 = {'name':'alex','weight':75}  #有相同的鍵不變，沒有的鍵更新
dic2.update(dic1)
print(dic1)#結果：{'age': 18, 'name': 'zhang', 'sex': 'male'}
print(dic2)#結果：{'name': 'zhang', 'weight': 75, 'age': 18, 'sex': 'male'}

查

dic1 = {'age':18,'name':'zhang','sex':'male'}
print(dic1.keys(),type(dic1.keys()))    #結果：dict_keys(['age', 'name', 'sex']) <class 'dict_keys'>；返回值當作列表
print(dic1.values(),type(dic1.values()))#結果：dict_values([18, 'zhang', 'male']) <class 'dict_values'>
print(dic1.items(),type(dic1.items()))  #結果：dict_items([('age', 18), ('name', 'zhang'), ('sex', 'male')]) <class 'dict_items'>；列表裏面是元組，元組裏面是鍵值

dic1 = {'age':18,'name':'zhang','sex':'male'}
value1 = dic1['name']
print(value1)　　　　　　　　　　#結果：zhang
# value1 = dic1['name1']  　　#沒有這個值會報錯
# print(value1)

get()，首選get

dic1 = {'age':18,'name':'zhang','sex':'male'}
print(dic1.get('name'))
print(dic1.get('name1'))    #結果：None；沒有的話不會報錯，會返回None
print(dic1.get('name1','沒有這個鍵'))    #結果：沒有這個鍵；能夠返回自定義的信息

遍歷字典的鍵值

dic1 = {'age':18,'name':'zhang','sex':'male'}
for i in dic1:
    print(i)　　　　#結果：age，name,sex;什麼都不寫。默認打印的是鍵
for i in dic1.keys():
    print(i)　　　　#結果：age，name,sex
for i in dic1.values():     #打印值
    print(i)　　　　#結果：18,zhang,male

items()：返回能夠遍歷的（鍵，值）元組數組

dic1 = {'age':18,'name':'zhang','sex':'male'}
for i in dic1.items():
    print(i)#結果：('age', 18)
                # ('name', 'zhang')
                # ('sex', 'male')

去括號，打印鍵值

dic1 = {'age':18,'name':'zhang','sex':'male'}
for key, value in dic1.items():
    print(key, value)#結果：age 18
                            # name zhang
                            # sex male

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。