基礎(chǔ)元素
學(xué)習(xí)一門編程語言的時候，我最先考慮的事情就是如何操作值，值（value）在程序組可以是一個數(shù)字1,2,3,4，字符'hello,word'.我們使用變量來保存這些值。又把變量保存的值成為對象，計算機(jī)會給變量的對象和變量分配內(nèi)存空間。python使用的內(nèi)存分配方式成為引用語義或者對象語義，而像c語言使用的時值語義。接下來具體說明一下這兩種語義的區(qū)別。
值語義：所謂值語義是指目標(biāo)對象由源對象拷貝生成，且生成后與源對象完全無關(guān)，彼此獨立存在，改變互不影響。例如c語言中的 int類型。
對象語義：指一個對象由源對象拷貝生成，且生成后與源對象依然保存著聯(lián)系，共享底層資源，對任何一個的改變都將隨之改變另一個。python使用的就是這種對象語義。
值語義的好處就在于生成后的對象與源語義不再有聯(lián)系，這樣復(fù)制的對象操作性就比較強(qiáng)，且不容易造成bug，不過，因此值語義的代碼會比較復(fù)雜，我們需要花許多精力在存儲和設(shè)計數(shù)據(jù)結(jié)構(gòu)去獲得好的性能上。而對象語義 python的不需要去考慮存儲問題，python的變量與值是通過鏈接結(jié)構(gòu)來進(jìn)行聯(lián)系的。對象與對象之間也是使用鏈接結(jié)構(gòu)來相互聯(lián)系。這樣最直接的好處是提高了開發(fā)人員的效率，我們不需要花時間在數(shù)據(jù)結(jié)構(gòu)的設(shè)計上，python內(nèi)部就已經(jīng)為我們很好地處理了，管理和存儲的問題。當(dāng)然，這樣的弊端就是靈活性下降，對象語義本身也會帶來許多的bug。
使用python編程需要注意兩方面的事情第一，我們不可避免需要自己設(shè)計一些數(shù)據(jù)結(jié)構(gòu)來提升效率。第二，我們需要清楚了解python高級數(shù)據(jù)結(jié)構(gòu)的性質(zhì)，才能有效的使用他們。
python的變量定義方式簡單，不需特定的定義如c語言中定義一個變量的方式是 int c=1，python的定義變量方式如下：
int
c
=
1
#c語言
c
=
1
#python的數(shù)字類型
d
=
'hello,word'
#字符串類型
e
=
[
1
,
2
,
3
]
#list類型
由此可見python的變量預(yù)定義是在賦值的時候就定義了，上面的例子中，c，d，e就被稱為變量，1，‘hello,word’，[1,2,3]就是所對應(yīng)的的值。=視為賦值語句。
常量或者成為標(biāo)量
python語言中除了變量以外還有不可變的元素，稱之為常量Python的常量有四類：
- int：整數(shù)。
- float：實數(shù)。
- bool：布爾型
- None：
python的變量的命名：在知道變量的作用是表示值。接下來需要了解的時如何給變量命名，python的變量名可以包含大小寫字母和數(shù)字和下劃線，但是不能以數(shù)字開頭且要避免使用關(guān)鍵字作為變量名。關(guān)鍵字就是在系統(tǒng)中已經(jīng)被使用的單詞，不能被使用。
python3中保留的關(guān)機(jī)字有：and、as、assert（斷言）、break、class（類）、continue（繼續(xù)）、def、del、elif（判斷語句）、else（判斷語句）、execpt（）、flase（非）、finally（異常）、for（循環(huán)）、from（導(dǎo)入）、global（全局）、if（如果）、import（導(dǎo)入）、in（在）、is（是）、lambda（隱函數(shù)）、nonlocal（非本地）、none（空）、not（非）、or（或者）、pass（占空）、raise（異常）、return（返回）、true（真）、try（異常關(guān)鍵詞）、while（循環(huán)語句）、with（with語句）、yield（生成器）。
python3的掛技能見此常用的查看python類型的函數(shù)時type。
a
=
1
b
=
'hello'
c
=
1.111
print
(
type
(
a
)
,
type
(
b
)
,
type
(
c
)
)
接下來開始介紹python的數(shù)據(jù)結(jié)構(gòu)，python提供了許多標(biāo)準(zhǔn)的數(shù)據(jù)結(jié)構(gòu)，這些數(shù)據(jù)結(jié)構(gòu)也有許多的操作，通過python的這些標(biāo)準(zhǔn)數(shù)據(jù)結(jié)構(gòu)能夠更方便的進(jìn)行編程操作，接下來的學(xué)習(xí)目的是去看一看python的數(shù)據(jù)結(jié)構(gòu)和其操作。
python的數(shù)據(jù)結(jié)構(gòu)有：數(shù)字、列表（list）、元組（tupe）、字符串（string）、字典（dict）。
數(shù)字
數(shù)字是所有編程語言都會講到的一種數(shù)字結(jié)構(gòu)，其表達(dá)的方式差別不大，無非就是精度不同，就是在系統(tǒng)中所占的內(nèi)存不一樣，下列詳細(xì)的介紹。
- 一般整數(shù)：1,2,3,4,5（就是c語言中的長整型，也就是32位）
- 長整型數(shù)：9999999999999L（無限長度）
- 浮點數(shù)：1.2,1.44，3.14e-10（C語言中的雙精度）
- 八進(jìn)制和十六進(jìn)制：0177,0x99
- 復(fù)數(shù)常量：3+3j
- 二進(jìn)制：0b111（以0b開頭）
- 八進(jìn)制：0o11（以0o開頭）
- 十六進(jìn)制：0x22（以0x開頭）
注意：在python3中int類型就是指代長整型數(shù)，不用再最后加’L’。
上述就是python3的數(shù)字的數(shù)據(jù)結(jié)構(gòu)，伴隨著數(shù)字類型，需要繼續(xù)介紹常用的運(yùn)算符，畢竟有了運(yùn)算符，數(shù)字?jǐn)?shù)據(jù)結(jié)構(gòu)就可以完成一些簡單的編程。
運(yùn)算符
+（加法） -（減法） *（乘法） **取冪 /（除法） //（向下整除） %（取模） <<（左移） >>（右移） &（按位與）
|（按位或） ^（按位異或） ~按位取反 <（小于） >（大于） <=（小于等于） >=（大于等于） ==（等于） !=（不等于）
<>（不等于） +=（加法賦值） -=（減法賦值）*=（乘法賦值） /=（除法賦值） //=（整除賦值） %=（取模賦值） **=（取冪賦值）
&=（按位與賦值） |=（按位或賦值） ^=（按位異或賦值） >>=（左移賦值） <<= （右移賦值）
以上就是常用的一些運(yùn)算符，下面將舉一些例子來對上述的運(yùn)算符和數(shù)字?jǐn)?shù)據(jù)結(jié)構(gòu)做一些運(yùn)算。
a
=
44
b
=
55
#加法
c
=
a
+
b
print
(
f
'a+b={c}'
)
#減法
c
=
b
-
a
print
(
f
'a-b={c}'
)
#乘法
c
=
b
*
a
print
(
f
'a*b={c}'
)
#2次冪
c
=
a
**
2
print
(
f
'a**b={c}'
)
#除法
c
=
b
/
a
print
(
f
'ab={c}'
)
#向下整除
c
=
b
//
a
print
(
f
'a+b={c}'
)
#取模
c
=
b
%
a
print
(
f
'a+b={c}'
)
#加法賦值
b
+=
a
print
(
f
'b+=a'
)
#減法賦值
b
-=
a
print
(
f
'b-=a:'
)
#乘法賦值
b
*=
a
print
(
f
'b*=a:'
)
#除法賦值
b
/=
a
print
(
f
'b/=a:'
)
#整除賦值
b
//=
a
print
(
f
'b//=a:'
)
#取模賦值
b
%=
a
print
(
f
'b%=a:'
)
#取冪賦值
a
**=
2
print
(
f
'b**=a:{a}'
)
#左移
d
=
0b001
c
=
d
<<
2
h
=
bin
(
c
)
print
(
f
'd左移{h}'
)
#右移
d
=
0b0100
c
=
d
>>
1
h
=
bin
(
c
)
print
(
f
'd左移{h}'
)
#按位與
a
=
0b0001
b
=
0b1000
c
=
a
&
b
print
(
f
'按位與{bin(c)}'
)
#按位或
a
=
0b0001
b
=
0b1000
c
=
a
|
b
print
(
f
'按位與{bin(c)}'
)
#按位異或
a
=
0b0001
b
=
0b1000
c
=
a
^
b
print
(
f
'按位與{bin(c)}'
)
#按位取反
a
=
0b0001
b
=
0b1000
c
=
~
a
print
(
f
'按位與{bin(c)}'
)
#小于
a
=
11
b
=
2
print
(
a
<
b
)
#大于
a
=
11
b
=
2
print
(
a
>
b
)
#等于
a
=
11
b
=
2
print
(
a
==
b
)
#不等于
a
=
11
b
=
2
print
(
a
!=
b
)
a+b=99
a-b=11
a*b=2420
a**b=1936
ab=1.25
a+b=1
a+b=11
b+=a99
b-=a:55
b*=a:2420
b/=a:55.0
b//=a:1.0
b%=a:1.0
b**=a:1936
d左移0b100
d左移0b10
按位與0b0
按位與0b1001
按位與0b1001
按位與-0b10
False
True
False
True
運(yùn)算符 有相應(yīng)的運(yùn)算優(yōu)先級，優(yōu)先級用于數(shù)據(jù)結(jié)構(gòu)的符合運(yùn)算時計算順序。下列列出運(yùn)算優(yōu)先級：
1. lambda
2. or
3. and
4. not x
5. in，not in
6. is，is not
7. <，<=，>，>=，!=，==
8. |
9. ^
10. &
11. <<，>>
12. +，-
13. *，/，%
14. +x，-x
15. ~x
16. **
17. x.attribute #列表
18. x[index] #列表
19. x[index:index]
20. f(arguments...)
21. (experession,...)
22. [expression,...]
23. {key:datum,...}
24. 'expression,...'
字符串
字符串是python中用于保存字符的數(shù)據(jù)結(jié)構(gòu)，不同于c語言中的，python中沒有單個字符串這種數(shù)據(jù)結(jié)構(gòu)，所有的字符都同一保存在字符串?dāng)?shù)據(jù)結(jié)構(gòu)中。字符串屬于不可變序列，所謂的序列就是一個有順序的點結(jié)構(gòu)，不可變序列就是說該序列結(jié)構(gòu)不能夠原地修改。
python3中有三種字符串接口，使用這些接口能夠進(jìn)行字符串的轉(zhuǎn)換
- str：一個字符不易變序列-ASCLL,和更豐富的Unicode。
- bytes：一個不易變的短整型序列，用于二進(jìn)制數(shù)據(jù)的字節(jié)值。
- bytearray：字節(jié)的易變變量。
a
=
1
print
(
f
'a的類型為：{type(a)}'
,
a
)
b
=
str
(
a
)
print
(
f
'b的類型為：{type(b)}'
,
b
)
c
=
bytes
(
a
)
print
(
f
'c的類型為：{type(b)}'
,
c
)
d
=
bytearray
(
a
)
print
(
f
'd的類型為：{type(b)}'
,
d
)
a的類型為：
1
b的類型為：
1
c的類型為：
b'\x00'
d的類型為：
bytearray(b'\x00')
在編程語言字符串中會包含一些特殊的字符如“\”這種的就稱之為轉(zhuǎn)義字符。
1. \newline 忽略換行
2. \\ 反斜杠(\)
3. \' 單引號(')
4. \" 雙引號(")
5. \a 蜂鳴（bell）
6. \b 空格
7. \f 換頁
8. \n 換行
9. \r 回車
10. \t 水平制表符
11. \v 豎直制表符
12. \other 非轉(zhuǎn)義字符
13. \O NULL
14. \OOO OCTAL
15. \xhh hex(最多兩位數(shù)字)
16. \uhhhh Unicode用4位十六進(jìn)制來表示一個字符
17. \uhhhhhhhh Unicode用8位十六進(jìn)制來表示一個字符
以上就是python中的轉(zhuǎn)義字符，接下來舉一些例子。
#換行
a
=
'asdfghjkk\nsssssss'
print
(
a
)
#反斜杠(\)
a
=
'asdfghjkk\\'
print
(
a
)
# 單引號(')
a
=
'asdfghjkk\''
print
(
a
)
#\雙引號(")
a
=
'asdfghjkk\"'
print
(
a
)
#蜂鳴（bell）
a
=
'asdfghjkk\a'
print
(
a
)
#空格
a
=
'asdfghjkk\bssss'
print
(
a
)
#換頁
a
=
'asdfghjkk\fssss'
print
(
a
)
#回車
a
=
'asdfghjkk\rssss'
print
(
a
)
#水平制表符
a
=
'asdfghjkk\tssss'
print
(
a
)
#豎直制表符
a
=
'asdfghjkk\vssss'
print
(
a
)
#非轉(zhuǎn)義字符
a
=
'asdfghjkk\ vssss'
print
(
a
)
#NULL
a
=
'asdfghjkk\0vssss'
print
(
a
)
#Unicode十六位字符串
s
=
u
'py\x74h\u4e2don'
print
(
s
)
asdfghjkk
sssssss
asdfghjkk\
asdfghjkk'
asdfghjkk"
asdfghjkk
asdfghjkkssss
asdfghjkk ssss
ssss
asdfghjkk ssss
asdfghjkk ssss
asdfghjkk\ vssss
asdfghjkk?vssss
pyth中on
字符串方法
中所周知，pyhon的簡單與便利源于眾多的內(nèi)置數(shù)據(jù)結(jié)構(gòu)和其所對應(yīng)的的方法。熟練的掌握這些方法能夠高效的進(jìn)行編程。
```
1. lambda
2. or
3. and
4. not x
5. in，not in
6. is，is not
7. <，<=，>，>=，!=，==
8. |
9. ^
10. &
11. <<，>>
12. +，-
13. *，/，%
14. +x，-x
15. ~x
16. **
17. x.attribute #列表
18. x[index] #列表
19. x[index:index]
20. f(arguments...)
21. (experession,...)
22. [expression,...]
23. {key:datum,...}
24. 'expression,...'
字符串格式化
字符串格式化的意思是就是一個字符串中如果其中有一個片段需要用一個變量代替，這種方式叫做字符串格式化。
python中有兩種方式實現(xiàn)一種是%運(yùn)算符，一種是{}置換對象。接下來看一看{}的使用方式。
{}源于 str.format(),在使用的時候使用{}和：去代替以往的%作為置換對象。同時也提拱了許多類似于索引，切片的操作。
```python
#{}表達(dá)方式
a='KD'
b='curry'
c='green'
print('2018 nba FMVP is {},or {},or {}?'.format(a,b,c))# 不設(shè)置指定位置，按默認(rèn)順序
print('2018 nba FMVP is {1},or {0},or {2}?'.format(a,b,c))# 設(shè)置指定位置
print('2018 nba FMVP is {1},or {0},or {2}? is {d[4]} '.format(a,b,c,d='kbbrant'))#索引制定關(guān)鍵字d的字符串的第五個字符
#配合：使用
print('2019 year have {:.2f}'.format(3))#對于數(shù)字保留小數(shù)點后兩位
print('2019 year have {:.0f}'.format(3.1415))#對于數(shù)字不保留小數(shù)
print('2019 year have {:0>2d}'.format(3))#用數(shù)字1去填充，寬度為2,>表示填充左邊
print('2019 year have {:,}'.format(3123000))#用，分割數(shù)字,沒三位一分
print('2019 year have {:.3%}'.format(31.2))#用%表示百分比,指數(shù)的話將%替代為e
2018 nba FMVP is KD,or curry,or green?
2018 nba FMVP is curry,or KD,or green?
2018 nba FMVP is curry,or KD,or green? is a
2019 year have 3.00
2019 year have 3
2019 year have 03
2019 year have 3,123,000
2019 year have 3120.000%
除了上述以外的操作還有
^, <, > 分別是居中、左對齊、右對齊，后面帶寬度， : 號后面帶填充的字符，只能是一個字符，不指定則默認(rèn)是用空格填充。
+ 表示在正數(shù)前顯示 +，負(fù)數(shù)前顯示 -； （空格）表示在正數(shù)前加空格
b、d、o、x 分別是二進(jìn)制、十進(jìn)制、八進(jìn)制、十六進(jìn)制。
#之前的print(f'a的類型為：{type(a)}')這種寫法是print('a的類型為：{type(a)}'.format(a))的簡寫，也是可以的。
上述簡單介紹了字符串格式化中{}方法的使用，然后在對%運(yùn)算的方法做一個介紹。
%運(yùn)算符實現(xiàn)字符串格式化的方法和c語言中的類似，都是使用%加一個關(guān)鍵的方式去實現(xiàn)對應(yīng)的字符串的格式化。
s 字符串
r 字符串（使用repr()）
c 字符（int 或 str）
d 小數(shù)（基于整數(shù)10）
i 整數(shù)
o 八進(jìn)制
x 十六進(jìn)制
X 大寫的x
e 浮點指數(shù)
E 大寫的e
f 浮點數(shù)
F 大寫的f
% 字面的%
g 浮點e或者f
G 大寫的g
#實例
print
(
' i am a %s,i am %d year old'
%
(
'man'
,
21
)
)
i am a man,i am 21 year old
字符串有許多的操作方法，熟悉這些操作方法能夠靈活的使用字符串結(jié)構(gòu)應(yīng)用于各種重大任務(wù)中。下列就對這些方法進(jìn)行詳細(xì)介紹：
#創(chuàng)建字符串
s1
=
' My name is Linus Torvalds and I am your god.'
s2
=
'linux'
#字符串表達(dá)式
#字符串拼接
print
(
'字符串拼接'
,
s1
+
s2
)
#字符串重復(fù)3次
print
(
'字符串重復(fù)3次'
,
s2
*
3
)
#字符串索引
print
(
'第十三個字符'
,
s1
[
12
]
)
#第十三個字符
#字符串切片，字符串的某一段
print
(
'從第二個字符到第十三個字符'
,
s1
[
1
:
12
]
)
#從第二個字符到第十三個字符
#求字符串的長度
print
(
'字符串的長度'
,
len
(
s1
)
)
#字符串方法
#把字符串的第一個字符小寫
print
(
'把字符串的第一個字符小寫'
,
s1
.
capitalize
(
)
)
#返回一個原字符串居中,并使用空格填充至長度 width 的新字符串
print
(
'填充'
,
s2
.
center
(
20
)
)
#返回一個原字符串居中,并使用空格填充至長度 width 的新字符串
#返回 str 在 string 里面出現(xiàn)的次數(shù)，如果 beg 或者 end 指定則返回指定范圍內(nèi) str 出現(xiàn)的次數(shù)
print
(
'm 在 s1中出現(xiàn)的次數(shù)'
,
s1
.
count
(
'm'
)
)
#檢查字符串是否以 obj 結(jié)束，如果beg 或者 end 指定則檢查指定的范圍內(nèi)是否以 obj 結(jié)束，如果是，返回 True,否則返回 False.
print
(
's1 是否以 god 結(jié)束'
,
s1
.
endswith
(
'god'
)
)
#檢測 str 是否包含在 string 中，如果 beg 和 end 指定范圍，則檢查是否包含在指定范圍內(nèi)，如果是返回開始的索引值，否則返回-1
print
(
s1
.
find
(
'god'
)
)
#格式化
s1
.
format
(
)
#同find
s1
.
index
(
'god'
)
#如果 string 至少有一個字符并且所有字符都是字母或數(shù)字則返ture
print
(
's`中是否全是字母或者數(shù)字'
,
s1
.
isalnum
(
)
)
#如果 string 至少有一個字符并且所有字符都是字母則返回 True,否則返回 False
print
(
's1 中都是字符？'
,
s1
.
isalpha
(
)
)
#如果 string 只包含十進(jìn)制數(shù)字則返回 True 否則返回 False.
print
(
s1
.
isdecimal
(
)
)
#如果 string 只包含十進(jìn)制數(shù)字則返回 True 否則返回 False.
print
(
's1中是否包含十進(jìn)制數(shù)'
,
s1
.
isdecimal
(
)
)
#如果 string 只包含數(shù)字則返回 True 否則返回 False.
print
(
's1是否只包含數(shù)字'
,
s1
.
isdigit
(
)
)
#如果 string 中包含至少一個區(qū)分大小寫的字符，并且所有這些(區(qū)分大小寫的)字符都是小寫，則返回 True，否則返回 False
print
(
's2 是否全為者小寫'
,
s2
.
islower
(
)
)
#如果 string 中只包含數(shù)字字符，則返回 True，否則返回 False
print
(
's1中只包含數(shù)字'
,
s1
.
isnumeric
(
)
)
#如果 string 是標(biāo)題化的(見 title())則返回 True，否則返回 False
print
(
'如果 s1全為大寫'
,
s1
.
isupper
(
)
)
#以 string 作為分隔符，將 seq 中所有的元素(的字符串表示)合并為一個新的字符串
print
(
' '
.
join
(
s2
)
)
#轉(zhuǎn)換 string 中所有大寫字符為小寫.
print
(
's1 中所有大寫為小寫'
,
s1
.
lower
(
)
)
#返回字符串 str 中最大的字母。
print
(
's2中最大的字母為：'
,
max
(
s2
)
)
#返回字符串 str 中最小的字母。
print
(
's1中最大的字母為：'
,
min
(
s2
)
)
#把 string 中的 str1 替換成 str2,如果 num 指定，則替換不超過 num 次.
print
(
's1中my換成'
,
s1
.
replace
(
'My'
,
'ss'
)
)
#
print
(
'以 str 為分隔符切片 string'
,
s1
.
split
(
)
)
#轉(zhuǎn)換 string 中的小寫字母為大寫
print
(
'小寫字母轉(zhuǎn)換大寫'
,
s2
.
upper
(
)
)
字符串拼接 My name is Linus Torvalds and I am your god.linux
字符串重復(fù)3次 linuxlinuxlinux
第十三個字符 L
從第二個字符到第十三個字符 My name is
字符串的長度 45
把字符串的第一個字符小寫 my name is linus torvalds and i am your god.
填充 linux
m 在 s1中出現(xiàn)的次數(shù) 2
s1 是否以 god 結(jié)束 False
41
s`中是否全是字母或者數(shù)字 False
s1 中都是字符？ False
False
s1中是否包含十進(jìn)制數(shù) False
s1是否只包含數(shù)字 False
s2 是否全為者小寫 True
s1中只包含數(shù)字 False
如果 s1全為大寫 False
l i n u x
s1 中所有大寫為小寫 my name is linus torvalds and i am your god.
s2中最大的字母為： x
s1中最大的字母為： i
s1中my換成 ss name is Linus Torvalds and I am your god.
以 str 為分隔符切片 string ['My', 'name', 'is', 'Linus', 'Torvalds', 'and', 'I', 'am', 'your', 'god.']
小寫字母轉(zhuǎn)換大寫 LINUX
以上就是字符串?dāng)?shù)據(jù)結(jié)構(gòu)大部分的方法，其余的方法可以見python的標(biāo)準(zhǔn)庫。介紹完字符串以及字符串的方法，接下來介紹的時另一種python中很關(guān)鍵的數(shù)據(jù)結(jié)構(gòu)列表。
列表
list
列表（list）是一種可變序列所以支持原地修改，又稱為容器序列，因為列表的可以包含數(shù)字、字符串、序列、列表等。因為是序列，所以列表有順序，類似于c語言中的數(shù)組，列表可以通過列表對象的偏移量來進(jìn)行取值。了解過列表是什么，接下來繼續(xù)了解列表創(chuàng)建方法和自帶方法。
#列表的創(chuàng)建
a
=
[
]
#創(chuàng)建一個空列表
b
=
[
1
,
2
,
3
,
4
]
#索引從0~3的數(shù)字列表
c
=
[
'a'
,
'b'
,
'c'
,
'b'
]
#索引從0`3的字串列表
d
=
[
[
333
]
,
[
2
]
,
[
23
]
,
[
33
]
]
#索引為0~3的列表列表
dd
=
'Talk is cheap. Show me the code.'
f
=
list
(
dd
)
print
(
'空列表'
,
a
)
print
(
'數(shù)字列表'
,
b
)
print
(
'字符串列表'
,
c
)
print
(
'列表列表'
,
d
)
print
(
'字符串列表'
,
f
)
#索引
print
(
'f列表的索引'
,
f
[
1
]
)
#切片
print
(
'f列表的切片'
,
f
[
1
:
5
]
)
#原地修改賦值
f
[
1
]
=
'w'
print
(
'修改后的f'
,
f
)
#原地切片賦值
f
[
1
:
4
]
=
'wrle'
print
(
'修改后的f'
,
f
)
#列表方法
#更新列表
k
=
[
]
k
.
append
(
'Google'
)
#給列表追加字符
k
.
append
(
'linux'
)
print
(
'更新列表為'
,
k
)
#刪除列表元素
del
k
[
0
]
print
(
'刪除列表后'
,
k
)
#列表拼接
c
.
extend
(
b
)
#在列表末尾一次性追加另一個序列中的多個值（用新列表擴(kuò)展原來的列表）
print
(
'列表拼接'
,
c
)
#統(tǒng)計某個元素在列表中出現(xiàn)的次數(shù)
cou
=
c
.
count
(
'b'
)
print
(
'c在某個元素中出現(xiàn)的次數(shù)'
,
cou
)
#從列表中找出某個值第一個匹配項的索引位置
index
=
c
.
index
(
'a'
)
print
(
'a 在c中的位置'
,
index
)
#將對象插入列表
c
.
insert
(
1
,
'ggg'
)
print
(
'將字符串插入c'
,
c
)
#移除列表中的一個元素（默認(rèn)最后一個元素），并且返回該元素的值
b
.
pop
(
)
print
(
'移除最后一個元素'
,
b
)
#移除列表中某個值的第一個匹配項
c
.
remove
(
1
)
print
(
'移除匹配的1'
,
c
)
#反向列表中元素
b
.
reverse
(
)
print
(
'反向列表b中元素'
,
b
)
#排序
b
.
sort
(
)
print
(
'排序后的b'
,
b
)
#從小到大排序
空列表 []
數(shù)字列表 [1, 2, 3, 4]
字符串列表 ['a', 'b', 'c', 'b']
列表列表 [[333], [2], [23], [33]]
字符串列表 ['T', 'a', 'l', 'k', ' ', 'i', 's', ' ', 'c', 'h', 'e', 'a', 'p', '.', ' ', 'S', 'h', 'o', 'w', ' ', 'm', 'e', ' ', 't', 'h', 'e', ' ', 'c', 'o', 'd', 'e', '.']
f列表的索引 a
f列表的切片 ['a', 'l', 'k', ' ']
修改后的f ['T', 'w', 'l', 'k', ' ', 'i', 's', ' ', 'c', 'h', 'e', 'a', 'p', '.', ' ', 'S', 'h', 'o', 'w', ' ', 'm', 'e', ' ', 't', 'h', 'e', ' ', 'c', 'o', 'd', 'e', '.']
修改后的f ['T', 'w', 'r', 'l', 'e', ' ', 'i', 's', ' ', 'c', 'h', 'e', 'a', 'p', '.', ' ', 'S', 'h', 'o', 'w', ' ', 'm', 'e', ' ', 't', 'h', 'e', ' ', 'c', 'o', 'd', 'e', '.']
更新列表為 ['Google', 'linux']
刪除列表后 ['linux']
列表拼接 ['a', 'b', 'c', 'b', 1, 2, 3, 4]
c在某個元素中出現(xiàn)的次數(shù) 2
a 在c中的位置 0
將字符串插入c ['a', 'ggg', 'b', 'c', 'b', 1, 2, 3, 4]
移除最后一個元素 [1, 2, 3]
移除匹配的1 ['a', 'ggg', 'b', 'c', 'b', 2, 3, 4]
反向列表b中元素 [3, 2, 1]
排序后的b [1, 2, 3]
以上就是列表的一些方法和表達(dá)方式，了解以上列表創(chuàng)建方式和方法就能基本的使用好列表。接下來介紹的時另一種數(shù)據(jù)結(jié)構(gòu)，字典。
字典
字典（dict），這是一種可變序列，所以也可以原地修改，字典和列表一樣是非常靈活的一種容器數(shù)據(jù)結(jié)構(gòu)，和列表不同的是，字典是屬于無序集合，同時字典是通過鍵值來存儲數(shù)據(jù)的不是通過對象偏移量。以下是字典數(shù)據(jù)結(jié)構(gòu)的一些創(chuàng)建和方法。
#創(chuàng)建
dic
=
{
}
#空字典
dic1
=
{
'鍵'
:
'值'
,
'ss'
:
'kk'
}
#這創(chuàng)建了兩個字符串字典，該鍵和值所對應(yīng)的是‘鍵’字符串和‘值’字符串
print
(
'dic1字典'
,
dic1
)
dic2
=
{
'kk'
:
{
'鍵'
:
'值'
}
}
#字典嵌套
print
(
'字典嵌套'
,
dic2
)
#索引
print
(
'字典通過鍵值索引'
,
dic1
[
'ss'
]
)
print
(
'字典通過鍵值索引'
,
dic2
[
'kk'
]
[
'鍵'
]
)
#嵌套索引
#賦值修改值
dic2
[
'kk'
]
[
'鍵'
]
=
'花花'
print
(
'字典通過鍵值賦值修改'
,
dic2
[
'kk'
]
[
'鍵'
]
)
#刪除鍵值
dict1
=
{
'Name'
:
'Zara'
,
'Age'
:
7
,
'Class'
:
'First'
}
del
dict1
[
'Name'
]
# 刪除鍵是'Name'的條目
print
(
'刪除name的字典'
,
dict1
)
dict1
.
clear
(
)
# 清空字典所有條目
print
(
'刪除所有的鍵值'
,
dict1
)
del
dict1
# 刪除字典
#返回一個字典的淺復(fù)制
dict2
=
dic2
.
copy
(
)
#
print
(
'復(fù)制后的字典'
,
dict2
)
#創(chuàng)建一個新字典，以序列 seq 中元素做字典的鍵，val 為字典所有鍵對應(yīng)的初始值
key
=
[
'a'
,
'b'
,
'c'
]
value
=
[
'c'
,
'b'
,
'a'
]
dict4
=
dict
.
fromkeys
(
key
,
value
)
print
(
'新創(chuàng)建的字典'
,
dict4
)
#返回指定鍵的值，如果值不在字典中返回default值
print
(
'f返回字典值'
,
dict4
.
get
(
'a'
)
)
#以列表返回可遍歷的(鍵, 值) 元組數(shù)組
print
(
'f返回字典值'
,
dict4
.
items
(
)
)
#以列表返回一個字典所有的鍵
print
(
'字典中所有鍵'
,
dict4
.
keys
(
)
)
#以列表返回字典中的所有值
print
(
'字典中所有值'
,
dict4
.
values
(
)
)
#刪除字典給定鍵 key 所對應(yīng)的值，返回值為被刪除的值。key值必須給出。 否則，返回default值。
print
(
'刪除字典中指定值'
,
dict4
.
pop
(
'b'
)
)
dic1字典 {'鍵': '值', 'ss': 'kk'}
字典嵌套 {'kk': {'鍵': '值'}}
字典通過鍵值索引 kk
字典通過鍵值索引 值
字典通過鍵值賦值修改 花花
刪除name的字典 {'Age': 7, 'Class': 'First'}
刪除所有的鍵值 {}
復(fù)制后的字典 {'kk': {'鍵': '花花'}}
新創(chuàng)建的字典 {'a': ['c', 'b', 'a'], 'b': ['c', 'b', 'a'], 'c': ['c', 'b', 'a']}
f返回字典值 ['c', 'b', 'a']
f返回字典值 dict_items([('a', ['c', 'b', 'a']), ('b', ['c', 'b', 'a']), ('c', ['c', 'b', 'a'])])
字典中所有鍵 dict_keys(['a', 'b', 'c'])
字典中所有值 dict_values([['c', 'b', 'a'], ['c', 'b', 'a'], ['c', 'b', 'a']])
刪除字典中指定值 ['c', 'b', 'a']
上述就是python中字典這種數(shù)據(jù)結(jié)構(gòu)，接下介紹另一種數(shù)據(jù)結(jié)構(gòu)元組。
元組
元組和列表類似所以元組的方法和列表大多相同，不同的是元組是不可變序列，所以不能再原地修改。接下來介紹一下元組的創(chuàng)建和方法。
#創(chuàng)建
t1
=
(
)
#空元組
t2
=
(
1
,
2
,
3
)
#數(shù)字元組
t3
=
(
1
,
'kk'
,
[
12
]
)
#綜合元組
t4
=
(
(
11
,
22
)
,
'kk'
,
(
[
12
]
)
)
#嵌套元組
print
(
t1
,
t2
,
t3
,
t4
)
#索引
print
(
't4索引'
,
t4
[
1
]
)
print
(
't4嵌套索引'
,
t4
[
0
]
[
1
]
)
#嵌套索引
print
(
't4切片索引'
,
t4
[
0
:
3
]
)
#切片索引
print
(
't4切片索引'
,
t4
[
0
:
3
]
)
#切片索引
#合并
print
(
't4合并'
,
t2
+
t3
)
#切片索引
#重復(fù)
print
(
't2重復(fù)'
,
t2
*
3
)
() (1, 2, 3) (1, 'kk', [12]) ((11, 22), 'kk', [12])
t4索引 kk
t4嵌套索引 22
t4切片索引 ((11, 22), 'kk', [12])
t4切片索引 ((11, 22), 'kk', [12])
t4合并 (1, 2, 3, 1, 'kk', [12])
t2重復(fù) (1, 2, 3, 1, 2, 3, 1, 2, 3)
集合
集合是一種易變的聚集，非順序，非映射集合支持?jǐn)?shù)學(xué)上的集合運(yùn)算，集合內(nèi)容只能是不變對象，就是說不可以是字典和列表，且內(nèi)容不重復(fù)。
#創(chuàng)建
set1
=
set
(
)
#創(chuàng)建空集
set2
=
{
'111'
,
'222'
,
'333'
}
集合的相關(guān)操作見pyhton標(biāo)準(zhǔn)庫。
python語句
python的語法規(guī)則是由表達(dá)式和語句構(gòu)成的，上面已經(jīng)介紹完了各種數(shù)據(jù)結(jié)構(gòu)和其自帶的方法，有這些就構(gòu)成了表達(dá)式。語句功能是聯(lián)系這些表達(dá)式，或者具有特定的功能，接下來詳細(xì)的介紹。
賦值語句
賦值語句的標(biāo)志是‘=’，上文中提到過python中使用的是對象語義，變量和對象使用的鏈接的方式，可以說賦值語句的作用就是將變量和對象鏈接起來，不僅如此，對象通過賦值語句對變量完成初始化。python中的賦值語句有四種：
- 基本賦值語句： a=b
- 多目標(biāo)賦值語句 a=b=c
- 順序賦值語句 a,b,c,d='1','2','3','4'
- 增量賦值語句 a+=2
一般情況下，順序賦值的對象是自左向右的賦值給變量，所以要求對象和變量的長度相等。除非下列這種方式：
- a,*b='1','2','3','4' 這樣的方式稱為擴(kuò)展序列賦值
#基本賦值，常用語對象的變量初始化
a
=
1
#多目標(biāo)賦值，給多個變量賦值相同的對象，
c
=
d
=
12
print
(
'c：%i,d為%i'
%
(
c
,
d
)
)
#元組賦值
(
q
,
w
,
e
,
r
)
=
1
,
2
,
3
,
4
print
(
'元組賦值為'
,
(
q
,
w
,
e
,
r
)
)
#擴(kuò)展序列將1賦值給a,剩下的賦值給b
a
,
*
b
=
1
,
2
,
3
,
4
print
(
a
,
b
)
#增量賦值就是運(yùn)算符中介紹的
a
+=
d
#相當(dāng)于a=a+d
print
(
'增量賦值'
,
a
)
c：12,d為12
元組賦值為 (1, 2, 3, 4)
1 [2, 3, 4]
增量賦值 13
表達(dá)式語句
表達(dá)式語句沒有說明沒有返回結(jié)果，也不會保存在內(nèi)存中。表達(dá)式語句有兩種：
- 用于print語句中
- 用于函數(shù)調(diào)用后不需要返回值
print語句
print語句是打印語句，在上文中可以明顯的看到，使用prin語句用于輸出變量的值并且，print是用‘，’去分不同的變量。
#print語句打印
print
(
'my name is linus ,i am your god'
,
32
,
[
21
]
)
my name is linus ,i am your god 32 [21]
if 語句
if語句被稱為是分支語句，if和elif和else共同組成了程序語言中的條件語句：
#if
a1
=
1
a2
=
2
if
a1
+
a2
==
2
:
#a1+a2=2為真執(zhí)行語句
print
(
'結(jié)果為2'
)
elif
a1
+
a2
>
2
:
#a1+a2>2為真執(zhí)行語句
print
(
'結(jié)果不為2'
)
else
:
#以上條件不為真執(zhí)行
print
(
'都不對'
)
結(jié)果不為2
while語句
while語句意思是結(jié)果為真就一直循環(huán)的語句。
for語句
for語句是一個序列的迭代。
#for語句
die
=
[
1
,
2
,
3
,
4
,
5
]
#這是一個列表也是一個序列
for
i
in
die
:
#for 語句會將die序列中每一個值賦值給i,并執(zhí)行語句。
print
(
i
)
#打印出所有的i值
#若果序列是一個數(shù)字序列，就可以表示為循環(huán)
for
i
in
die
:
#有5個數(shù)，循環(huán)五次
print
(
'循環(huán)%i次'
%
i
)
1
2
3
4
5
循環(huán)1次
循環(huán)2次
循環(huán)3次
循環(huán)4次
循環(huán)5次
pass語句
pass語句是一個什么都不做的占位語句，目的就是在一個函數(shù)或者一個語句中，不清楚需要做什么是用來占位，避免報錯的語句
break語句
break語句用于跳出最近的一個while或者for循環(huán)。
continue語句
continue語句用于跳出最近的一個while或者for循環(huán)回到循環(huán)的頂部。
del 語句
del 語句用于刪除變量，項目，鍵，分片，屬性。
def 語句
def 語句用于創(chuàng)建新的函數(shù)或者方法。
return語句
退出函數(shù)并返回一個表達(dá)式。
yield語句
創(chuàng)建返回一個生成器對象。
global語句
命名空間修改或者創(chuàng)建全局變量
nonlocal語句
聲明為局部變量引用
import\from語句
模塊導(dǎo)入語句
class語句
創(chuàng)建一個類
try/except/finally語句
捕捉異常
raise語句
引發(fā)異常
with/as語句
環(huán)境管理
assert語句
調(diào)試檢查
exec語句
執(zhí)行代碼字符串
上述就是python中的語句，某些相關(guān)的語句會會在后面介紹，至此，python的數(shù)據(jù)結(jié)構(gòu)和表達(dá)式語句部分就大概的介紹完了，通過上的內(nèi)容就能編寫一些腳本，想要編寫更復(fù)雜的腳本還需要學(xué)習(xí)函數(shù)與類的相關(guān)知識。
更多文章、技術(shù)交流、商務(wù)合作、聯(lián)系博主
微信掃碼或搜索：z360901061
微信掃一掃加我為好友
QQ號聯(lián)系： 360901061
您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機(jī)微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對您有幫助就好】元
