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