python3基礎筆記（二）python的基本資料型別與運算子
阿新 • • 發佈：2019-01-25
一、運算子
1.算術運算子
假設變數a的值是10，變數b的值是21，則 -
| 運算子 | 描述 | 示例 |
|---|---|---|
+ |
加法運算，將運算子兩邊的運算元增加。 | a + b = 31 |
- |
減法運算，將運算子左邊的運算元減去右邊的運算元。 | a – b = -11 |
* |
乘法運算，將運算子兩邊的運算元相乘 | a * b = 210 |
/ |
除法運算，用右運算元除左運算元 | b / a = 2.1 |
% |
模運算，用右運算元除數左運算元並返回餘數 | b % a = 1 |
** |
對運算子進行指數(冪)計算 | a ** b，表示10的21次冪 |
// |
地板除 - 運算元的除法，其結果是刪除小數點後的商數。 但如果其中一個運算元為負數，則結果將被保留，即從零(向負無窮大)捨去 | 9//2 = 4 ， 9.0//2.0 = 4.0, -11//3 = -4, -11.0//3 = -4.0 |
2.比較(關係)運算子
比較(關係)運算子比較它們兩邊的值，並確定它們之間的關係。它們也稱為關係運算符。假設變數a的值10，變數b的值是20，則 -
| 運算子 | 描述 | 示例 |
|---|---|---|
== |
如果兩個運算元的值相等，則條件為真。 | (a == b)求值結果為 false |
!= |
如果兩個運算元的值不相等，則條件為真。 | (a != b)求值結果為 true |
> |
如果左運算元的值大於右運算元的值，則條件成為真。 | (a > b)求值結果為 false |
< |
如果左運算元的值小於右運算元的值，則條件成為真。 | (a < b)true |
>= |
如果左運算元的值大於或等於右運算元的值，則條件成為真。 | (a >= b)求值結果為 false |
<= |
如果左運算元的值小於或等於右運算元的值，則條件成為真。 | (a <= b)求值結果為 true |
3.賦值運算子
假設變數a的值10，變數b的值是20，則 -
| 運算子 | 描述 | 示例 |
|---|---|---|
= |
將右側運算元的值分配給左側運算元 | c = a + b表示將a + b的值分配給c |
+= |
將右運算元相加到左運算元，並將結果分配給左運算元 | 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.邏輯運算子
Python語言支援以下邏輯運算子。假設變數a的值為True，變數b的值為False，那麼 -
| 運算子 | 描述 | 示例 |
|---|---|---|
and |
如果兩個運算元都為真，則條件成立。 | (a and b)的結果為False |
or |
如果兩個運算元中的任何一個非零，則條件成為真。 | (a or b)的結果為True |
not |
用於反轉運算元的邏輯狀態。 | not(a and b) 的結果為True。 |
5.按位運算子
按位運算子執行逐位運算。 假設變數a = 60; 和變數b = 13; 現在以二進位制格式，它們將如下 -
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
Python的內建函式bin()可用於獲取整數的二進位制表示形式。
以下是Python語言支援位運算操作符 -
| 運算子 | 描述 | 示例 |
|---|---|---|
& |
如果它存在於兩個運算元中，則操作符複製位到結果中 | (a & b) 結果表示為 0000 1100 |
| | | 如果它存在於任一運算元，則複製位。 | (a|b) = 61 結果表示為 0011 1101 |
^ |
二進位制異或。如果它是一個運算元集合，但不是同時是兩個運算元則將複製位。 | (a ^ b) = 49 (結果表示為 0011 0001) |
~ |
二進位制補碼，它是一元的，具有“翻轉”的效果。 | (~a ) = -61有符號的二進位制數，表示為1100 0011的補碼形式。 |
<< |
二進位制左移，左運算元的值由右運算元指定的位數左移。 | a << 2 = 240 (結果表示為 1111 0000) |
>> |
二進位制右移，左運算元的值由右運算元指定的位數右移。 | a >> 2 = 15(結果表示為0000 1111) |
6.成員運算子
Python成員運算子測試給定值是否為序列中的成員，例如字串，列表或元組。 有兩個成員運算子，如下所述 -
| 運算子 | 描述 | 示例 |
|---|---|---|
in |
如果在指定的序列中找到一個變數的值，則返回true，否則返回false。 |
- |
not in |
如果在指定序列中找不到變數的值，則返回true，否則返回false。 |
- |
7.身份運算子
身份運算子比較兩個物件的記憶體位置。常用的有兩個身份運算子，如下所述 -
| 運算子 | 描述 | 示例 |
|---|---|---|
is |
如果運算子任一側的變數指向相同的物件，則返回True，否則返回False。 |
|
is not |
如果運算子任一側的變數指向相同的物件，則返回True，否則返回False。 |
- |
8. 運算子優先順序
下表列出了從最高優先順序到最低優先順序的所有運算子，如下所示 -
| 序號 | 運算子 | 描述 |
|---|---|---|
| 1 | ** |
指數(次冪)運算 |
| 2 | ~ + - |
補碼，一元加減(最後兩個的方法名稱是[email protected]和[email protected]) |
| 3 | * / % // |
乘法，除法，模數和地板除 |
| 4 | + - |
|
| 5 | >> << |
向右和向左位移 |
| 6 | & |
按位與 |
| 7 | ^| |
按位異或和常規的“OR” |
| 8 | <= < > >= |
比較運算子 |
| 9 | <> == != |
等於運算子 |
| 10 | = %= /= //= -= += *= **= |
賦值運算子 |
| 11 | is is not |
身份運算子 |
| 12 | in not in |
成員運算子 |
| 13 | not or and |
邏輯運算子 |
二、資料型別：
1、數字
int（整型）
float（浮點型） def bit_length(self):
""" 返回表示該數字的時佔用的最少位數 """
"""
int.bit_length() -> int
Number of bits necessary to represent self in binary.
>>> bin(37)
'0b100101'
>>> (37).bit_length()
6
"""
return 0
def __int__(self):
""" 轉換為整數 """
""" x.__int__() <==> int(x) """
pass
#等價於 int(x)
2、字串：str
字串一旦建立之後就不能修改，若修改就會重新建立一個新的字串。
字串可以用 len() 函式來返回字串內含有多少字元（1）字串常用方法：
1、upper(self) ---->將字串中所有字母大寫，不去管其它非字母字元。
引數：無
返回值：字串
str1 = 'hello my name is 張'
print(str1.upper())
輸出：
HELLO MY NAME IS 張
2、lower(self) ---->把全部字母字元轉換成小寫，不去管其它非字母字元。
引數：無
返回值：字串
str1 = 'Zbuter'
print(str1.lower())
輸出：
zbuter3、swapcase(self) ---->將字串中的大小寫字元互換
引數：無
返回值：字串
str1 = '張Zbuter'
print(str1.swapcase())
輸出：
張zBUTER
4、count(self, sub, start=None, end=None) ---->計算字串中從 start 開始到 end 結束 sub 出現的次數 start 預設是字串開始 end 預設是字串結束
引數：
sub：字元或字串
start：開始的索引位置
end：結束的索引位置
返回值：字串中sub出現的次數
hello = 'hello world'
print(hello.count('o'))
print(hello.count('o',6))
輸出：
2
15、capitalize(self) ---->將字串的首字母大寫
引數：無
返回值：將字串的首字母大寫的字串
name = 'zjs'
print(name.capitalize())
輸出：
Zjs
6、casefold(self) 與 lower(self) ---->將字串小寫
引數：無
返回值：將字串小寫的字串
name = 'ZJS'
print(name.lower())
print(name.casefold())
輸出：
zjs
zjscasefold(self) 與 lower(self)的區別是：
lower() 只對 ASCII 也就是 'A-Z'有效，但是其它一些語言裡面存在小寫的情況就沒辦法了。文件裡面舉得例子是德語中'ß'的小寫是'ss'（這個我也不懂）
7、center(self, width, fillchar=None) ---->將字串居中用fillchar填充 一共width個字元 預設是使用空格填充 返回新的字串
引數：
width：新形成的字串長度，如果源字串比width指定的長度長則直接返回源字串
fillchar：指定一個字元來填充
返回值：填充後的字串
name = 'ZJS'
print(name.center(20))
print(name.center(20, '-'))
輸出：
ZJS
--------ZJS---------
8、ljust(self, width, fillchar=None) ---->返回一個長度為width，左對齊的字串，最右邊填充fillchar，預設為空格。width要大於len(str)，否則返回原字串。
str1 = 'Zbuter'
print(str1.ljust(20))
print(str1.ljust(20, '-'))
輸出：
Zbuter
Zbuter--------------
9、rjust(self, width, fillchar=None) ---->與ljust類似 右對齊
10、lstrip(self, chars=None) ---->返回一個去除前導字元的新字串，chars引數是一個字串，它包含了所有將要被移除的字元集合。預設為空格。
引數：
chars：字元集合
返回值：字串
str1 = ' www.zbuter.cn'
str2 = 'www.zbuter.cn'
print(str1.lstrip())
print(str2.lstrip('cnw.'))
輸出：
www.zbuter.cn
zbuter.cn
11、rstrip(self, chars=None) ---->與lsplit類似 從右側開始
12、strip(self, chars=None) ---->與lstrip和rstrip類似 在字串兩頭開始匹配。多用於清除字串兩端的空格
13、endswith(self, suffix, start=None, end=None) ---->判斷字串是否以 suffix 結尾 start 預設是字串開始 end 預設是字串結束
引數：
suffix：字尾
start：開始的索引位置
end：結束的索引位置
返回值：布林值
hello = 'hello world'
print(hello.endswith('ld'))
print(hello.endswith('asd'))
輸出：
True
False
14、startswith(self, prefix, start=None, end=None) ---->與endswith類似 判斷是否以prefix開頭
15、expandtabs(self, tabsize=8) ---->把字串中的 tab 符號('\t')轉為空格，tab 符號預設的空格數是 8。從頭開始數，數到第一個\t正好為8個空格，不足則補空格，如果還有\t，接著從第一個\t數到第二個\t仍然為8個空格，以此類推直到最後一個\t結束。
引數：
tabsize：指定轉換字串中的 tab 符號('\t')轉為空格的字元數，預設的字元數是8。
返回值：該方法返回字串中的 tab 符號('\t')轉為空格後生成的新字串。
hello = 'hello\tworld'
print(hello.expandtabs(4))
print(hello.expandtabs(10))
輸出：
hello world
hello world
16、find(self, sub, start=None, end=None) ---->在字串中查詢 sub 出現的位置
引數：
sub：指定查詢的字串或字元
start：開始的索引位置
end：結束的索引位置
返回值：sub出現的第一次的索引 如果不存在則返回-1
hello = 'hello\tworld'
print(hello.find('o'))
print(hello.find('z'))
輸出：
4
-117、rfind(self, sub, start=None, end=None) ---->與find類似 從右側查詢
18、index(self, sub, start=None, end=None) ---->在字串中查詢 sub 出現的位置
引數：
sub：指定查詢的字串或字元
start：開始的索引位置
end：結束的索引位置
返回值：sub出現的第一次的索引 如果不存在則丟擲異常
hello = 'hello\tworld'
print(hello.index('o'))
print(hello.index('z'))
輸出：
4
Traceback (most recent call last):
File "E:/zjs/Python/pythonTest/day01/day01/d1.py", line 36, in <module>
print(hello.index('z'))
ValueError: substring not found
19、rindex(self, sub, start=None, end=None) ---->與index類似 從右側查詢
20、title(self) ---->將字串中所有單詞的首字母大寫
引數：無
返回值：字串
str1 = 'hello my name is 張'
print(str1.title())
輸出：
Hello My Name Is 張
21、replace(self, old, new, count=None) ---->用 new 替換原字串中的 old ，count指定替換的次數
引數：
old：需要替換的字元（串）
new：替換的字元（串）
count：替換的次數不超過count次
返回值：字串
str1 = 'www.zbuter.cn'
str2 = 'www.zbuter.cn'
print(str1.replace('.', '。'))
print(str2.replace('.', '，', 1))
輸出：
www。zbuter。cn
www，zbuter.cn
22、partition(self, sep) ---->該方法用於拆分字串，返回一個包含三個元素的元組。如果未能在原字串中找到Sep，則元組的三個元素為：原字串，空串，空串；否則，從原字串中遇到的第一個Sep字元開始拆分，元組的三個元素為：Sep之前的字串，Sep字元，Sep之後的字串；
引數：
sep：分割標記
返回值：元祖
str1 = ' www.zbuter.cn'
str2 = 'www.zbuter.cn'
print(str1.partition('.'))
print(str2.partition('z'))
輸出：
(' www', '.', 'zbuter.cn')
('www.', 'z', 'buter.cn')23、rpartition(self, sep) ---->與partition類似 從右側查詢sep
24、split(self, sep=None, maxsplit=-1) ---->返回一個以Sep分隔的列表，maxsplit指定拆分次數（因此，列表中元素的個數為maxsplit + 1）。Sep預設為空格，maxsplit預設不限制拆分次數。
引數：
sep：分隔符
maxsplit：拆分次數
返回值：字串
str1 = 'www.zbuter.cn'
str2 = 'www.zbuter.cn'
print(str1.split('.'))
print(str2.split('.', 1))
輸出：
['www', 'zbuter', 'cn']
['www', 'zbuter.cn']
25、rsplit(self, sep=None, maxsplit=-1) ---->與 split 類似 從右側拆分
26、splitlines(self, keepends=None) ---->拆分一個包含多行的字串，以每行為一個元素返回一個列表 keepends是一個True字元或非零整數
引數：
keepends：是否在列表內也新增換行符
返回值：字串
str1 = '123\n456'
str2 = '123\n456'
print(str1.splitlines())
print(str2.splitlines(True))
輸出：
['123', '456']
['123\n', '456']
27、join(self, iterable) ---->使用連線符str來連線iterable物件中的元素，如果傳入一個非iterable物件，如整數、布林值等，將丟擲異常Type Error。
引數：iterable：使用字串來連線iterable
返回值：字串
str1 = 'Zbuter'
print(str1.join('12'))
print(str1.join('123'))
print(str1.join(123))
輸出：
1Zbuter2
1Zbuter2Zbuter3
Traceback (most recent call last):
File "E:/zjs/Python/pythonTest/day01/day01/d1.py", line 39, in <module>
print(str1.join(123))
TypeError: can only join an iterable28、zfill(self, width) ---->返回一個長度為width的數字字串，最左邊填充0。如果width小於等於原字串長度，則返回原字串。主要用於數字類字串的格式化。
引數：
width：填充的寬度
返回值：字串
str1 = 'aaa'
str2 = '123'
print(str1.zfill(5))
print(str2.zfill(5))
輸出：
00aaa
0012329、format(self, *args, **kwargs) ---->格式化字串
引數：
*args：是用來發送一個（非鍵值對）可變數量的引數列表給一個函式
**kwargs 允許你將不定長度的鍵值對, 作為引數傳遞給一個函式。 如果你想要在一個函式裡處理帶名字的引數, 你應該使用**kwargs。
返回值：格式化後的新字串
str1 = 'my name is {name} age is {age}'
str2 = 'my name is {0} age is {1}'
print(str1.format(name = 'zjs', age = 12))
print(str2.format('zjs', 12))
輸出：
my name is zjs age is 12
my name is zjs age is 12
更多參考：http://www.cnblogs.com/wupeiqi/articles/5484747.html
30、format_map(self, mapping) ----> 待更新
31、isalnum(self) ---->字串中是否只含數字、字母
引數：無
返回值：布林值
str1 = '123abc'
str2 = '123_abc'
print(str1.isalnum())
print(str2.isalnum())
輸出：
True
False
32、isalpha(self) ---->字串是否只含有字母
引數：無
返回值：布林值
str1 = 'abcdef'
str2 = '_abc'
print(str1.isalpha())
print(str2.isalpha())
輸出：
True
False33、isdecimal(self) ---->字串是否只包含十進位制字元。這種方法只存在於unicode物件。
引數：無
返回值：布林值
str1 = '123'
str2 = 'this123'
print(str1.isdecimal())
print(str2.isdecimal())
輸出：
True
False34、isdigit(self) ---->檢測字串是否只由數字組成。
引數：無
返回值：布林值
str1 = '123'
str2 = 'this123'
print(str1.isdigit())
print(str2.isdigit())
輸出：
True
False35、isidentifier(self) ---->判斷字串是否是合法的識別符號
引數：無
返回值：布林值
str1 = '_a'
str2 = '1a'
print(str1.isidentifier())
print(str2.isidentifier())
輸出：
True
False36、islower(self) ---->判斷字串是否全是小寫
引數：無
返回值：布林值
str1 = 'abcdefg'
str2 = 'Abcdefg'
print(str1.islower())
print(str2.islower())
輸出：
True
False37、isnumeric(self) ---->判斷字串是否只包含數字字元。數字字元範圍很大，一般來說，數字字元是擁有如下屬性值的字元：Numeric_Type=Digit, Numeric_Type=Decimal或Numeric_Type=Numeric。比較isdecimal()、isdigit()、isnumeric()，幾個方法檢測的範圍依次擴大。
引數：無
返回值：布林值
str1 = '123'
str2 = 'a123'
print(str1.isnumeric())
print(str2.isnumeric())
輸出：
True
False38、isprintable(self) ---->判斷字串所包含的字元是否全部可列印
引數：無
返回值：布林值
str1 = 'hello world'
str2 = 'hello\tworld'
print(str1.isprintable())
print(str2.isprintable())
輸出：
True
False39、isspace(self) ---->判斷字串是否僅包含空格或製表符
引數：無
返回值：布林值
str1 = ' \t \n'
str2 = ''
print(str1.isspace())
print(str2.isspace())
輸出：
True
False40、istitle(self) ---->判斷字串每個單詞的首字母是否大寫
引數：無
返回值：布林值
str1 = '張家順'
str2 = 'Zbuter'
str3 = '張家順Zbuter'
print(str1.istitle())
print(str2.istitle())
print(str3.istitle())
輸出：
False
True
True41、isupper(self) ---->與islower()相反 判斷字串是否全部大寫
42、encode(self, encoding='utf-8', errors='strict') ---->
43、decode(self, *args, **kwargs) ---->
44、maketrans(self, *args, **kwargs)
45、translate(self, table)
maketrans 與 translate 配合使用
str = '30416657'
trans = str.maketrans('0123456789', '零一二三四五六七八九')
print(str.translate(trans))
輸出：
三零四一六六五七（2）字串的索引：
str = 'zbuter'
print(str[0], str[1])
print(str[-1], str[-2]) # 負號代表在字串後面數
輸出：
z b
r estr[0]代表字串的第一個字元 以此類推
用於獲取字串中某一個字元
（3）字串的切片：
str = 'zbuter'
print(str[0:2])
print(str[:2]) # 與 str[0:2] 含義相同
print(str[:-1]) # 表示從 0 到 最後一個字元（不含）
print(str[2:-1]) #從第二個字元到最後一個字元）（不含）
輸出：
zb
zb
zbute
ute
（4）字串的長度
str = 'zbuter'
print(len(str))
輸出：
6
（5）字串內字元的遍歷
str1 = "hello my name is zjs"
for s in str1:
print(s)
輸出：
h
e
l
l
o
m
y
n
a
m
e
i
s
z
j
s
3、列表：list
建立列表：
name_list = ['zhang', 'wang', 'li']
或
name_list ＝ list(['zhang', 'wang', 'li'])列表內的元素是有序的
（1）常用方法：
1.append(self, p_object) ---->在列表最後追加一個元素
引數：p_object 追加的元素
返回值：None
ls = [1, '2', 'abc']
s = ls.append(5)
print(ls)
print(s)
輸出：
[1, '2', 'abc', 5] None
列表可以追加任意的資料型別。包括列表、元祖和字典。
2.clear(self) ---->清空字典
引數：無
返回值：None
ls = [1, '2', 'abc']
s = ls.clear()
print(ls)
print(s)
輸出：
[]
None
3.copy(self) ---->字典的淺拷貝 只拷貝直接子物件
引數：無
返回值：列表
ls = [1, '2', 'abc']
s = ls.copy()
print(ls)
print(s)
ls = []
print(ls)
print(s)
輸出：
[1, '2', 'abc'] [1, '2', 'abc'] [] [1, '2', 'abc']
4.count(self, value) ---->計算value在列表中出現的次數
引數：value 可以是任意型別
返回值：int型別的數字
ls = [1, '2', 'abc', 1, 1, 1]
s = ls.count(1)
print(ls)
print(s)
輸出：
[1, '2', 'abc', 1, 1, 1] 4
5.insert(self, index, p_object) ---->在 index 處插入p_object
引數：
index： 索引位置
p_object：需要插入的元素
返回值：int型別的數字
ls = [1, '2', 'abc']
s = ls.insert(1, 4)
print(ls)
print(s)
ls.insert(4, 4) #插入如果超出了列表的索引範圍則在最後一個位置插入
print(ls)
輸出：
[1, 4, '2', 'abc'] None [1, 4, '2', 'abc', 4]
6.index(self, value, start=None, stop=None) ---->查詢value從start開始到stop處出現的索引位置 如果不存在這個值會丟擲異常
引數：
value： 需要查詢的元素
start： 開始查詢的索引位置 預設是列表的第一個元素
stop： 結束查詢的索引位置 預設是列表的最後一個元素
返回值：int型別數字 value第一次出現的索引位置
ls = [0, '2', 'abc', 1, 1, 1]
s = ls.index(1, 2, 4)
print(s)
s = ls.index(1, 2, 3)
print(s)
輸出：
3 Traceback (most recent call last): File "E:/zjs/Python/pythonTest/day01/day01/d1.py", line 69, in <module> s = ls.index(1, 2, 3) ValueError: 1 is not in list
7.extend(self, iterable) ---->在列表後追加一個可迭代的值
引數：iterable 追加的可迭代元素
返回值：None
ls = [0, '2', 'abc', 1, 1, 1]
ex = ['a', 'bc', 1, 3]
s = ls.extend(ex)
print(ls)
print(s)
輸出：
[0, '2', 'abc', 1, 1, 1, 'a', 'bc', 1, 3] None
與append不同，
append一個列表是把列表整體追加到列表尾部，
extend則是一個一個追加到列表的末尾，
extend不接受數字型別，只能傳遞一個可迭代物件
8.pop(self, index=None) ---->刪除列表中最後一個元素。若index指定則刪除index處的元素
引數：index 刪除的元素索引
返回值：None
ls = [0, '2', 'abc', 1, 1, 1]
ex = ['a', 'bc', 1, 3]
s = ls.pop()
print(ls)
print(s)
s = ls.pop(2)
print(ls)
print(s)
輸出：
[0, '2', 'abc', 1, 1] 1 [0, '2', 1, 1] abc
9.remove(self, value) ---->從列表中刪除第一個value匹配值
引數：value 需要刪除的元素
返回值：None
ls = [0, '2', 'abc', 1, 1, 1]
s = ls.remove(1)
print(ls)
print(s)
輸出：
[0, '2', 'abc', 1, 1] None
10.reverse(self) ---->將列表逆置
引數：None
返回值：None
ls = [0, '2', 'abc', 1, 1, 1]
s = ls.reverse()
print(ls)
print(s)
輸出：
[1, 1, 1, 'abc', '2', 0] None
11.sort(self, key=None, reverse=False) ---->對列表進行排序 若reverse指定為True則為從大到小排序
引數：
key：待更新
reverse：排序方式 預設為升序排列
返回值：None
ls = [4, 1, 3, 6, 7, 2]
s = ls.sort()
print(ls)
print(s)
s = ls.sort(reverse=True)
print(ls)
print(s)
輸出：
[1, 2, 3, 4, 6, 7] None [7, 6, 4, 3, 2, 1] None
（2）訪問列表中的值：
使用索引的方式訪問列表：
ls = ['baidu', 'souhu', 1995, 2018];
print("ls[0]: ", ls[0])
print("ls[1:5]: ", ls[1:5])
輸出：
ls[0]: baidu ls[1:5]: ['souhu', 1995, 2018]
獲得列表中第一個值和最後一個值。
ls = ['baidu', 'souhu', 1995, 2018];
name, *_, year = ls # *（星）代表name和year中間的所有元素的之賦值給 _（下劃線）。
print(name)
print(_)
print(year)
輸出：
baidu ['souhu', 1995] 2018
（3）列表的更新：
ls = ['baidu', 'souhu', 1995, 2018];
print("ls[3]: ", ls[3])
ls[3] = 1111
print("更新後的ls[3]: ", ls[3])
輸出：
ls = ['baidu', 'souhu', 1995, 2018]; print("ls[3]: ", ls[3]) ls[3] = 1111 print("更新後的ls[3]: ", ls[3])
（4）列表元素的刪除：
ls = ['baidu', 'souhu', 1995, 2018, 'test', 'hello', [1,2,3]]
del ls[2]
print(ls)
ls.remove(2018)
print(ls)
ls.pop()
print(ls)
ls.clear() #無論列表中有多少元素都全部刪除
print(ls)
輸出：
['baidu', 'souhu', 2018, 'test', 'hello', [1, 2, 3]] ['baidu', 'souhu', 'test', 'hello', [1, 2, 3]] ['baidu', 'souhu', 'test', 'hello'] []
（5）列表的操作符：
列表對 + 和 * 的操作符與字串相似。+ 號用於組合列表，* 號用於重複列表。
如下所示：
| Python 表示式 | 結果 | 描述 |
|---|---|---|
| len([1, 2, 3]) | 3 | 長度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 組合 |
| ['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重複 |
| 3 in [1, 2, 3] | True | 元素是否存在於列表中 |
| for x in [1, 2, 3]: print(x, end=" ") | 1 2 3 | 迭代 |
（5）列表的遍歷：
list1 = ['abc', 123, (1, 2), [22, 33, 44, "ttt"]]
for item in list1:
print(item)
輸出：
abc 123 (1, 2) [22, 33, 44, 'ttt']
4、元祖：tuple
元祖的建立方法：
ages = (11, 22, 33, 44, 55)
或
ages = tuple((11, 22, 33, 44, 55))
元祖的元素是有序的。
Python 的元組與列表類似，不同之處在於元組的元素不能修改。
元組使用小括號，列表使用方括號。
（1）元祖常用方法：
1.count(self, value) ---->與列表中count函式相同
2.index(self, value, start=None, stop=None) ---->與列表中index函式相同
（2）元祖的訪問：
tuple1 = ('baidu', 'souhu', 1995, 2018, 'test', 'hello', [1,2,3])
print(tuple1[1])
print(tuple1[2:4])
輸出：
souhu
(1995, 2018)
獲得元祖中第一個值和最後一個值。
ls =('baidu', 'souhu', 1995, 2018)
name, *_, year = ls # *（星）代表name和year中間的所有元素的之賦值給 _（下劃線）。
print(name)
print(_) # 如果是元祖取出來的會是列表
print(year)輸出：
baidu
['souhu', 1995]
2018
（3）元祖的修改和刪除：
元祖的直接子元素不能被修改和刪除，但間接子元素可以被修改或刪除
元祖只能被整體刪除。
tuple1 = ('baidu', 'souhu', 1995, 2018, 'test', 'hello', [1,2,3])
tuple1[6][1] = 666
print(tuple1)
輸出：
('baidu', 'souhu', 1995, 2018, 'test', 'hello', [1, 666, 3])
（4）元祖的運算子：
與字串一樣，元組之間可以使用 + 號和 * 號進行運算。這就意味著他們可以組合和複製，運算後會生成一個新的元組。
| Python 表示式 | 結果 | 描述 |
|---|---|---|
| len((1, 2, 3)) | 3 | 計算元素個數 |
| (1, 2, 3) + (4, 5, 6) | (1, 2, 3, 4, 5, 6) | 連線 |
| ('Hi!',) * 4 | ('Hi!', 'Hi!', 'Hi!', 'Hi!') | 複製 |
| 3 in (1, 2, 3) | True | 元素是否存在 |
| for x in (1, 2, 3): print (x,) | 1 2 3 | 迭代 |
（5）元祖的遍歷：
tuple1 = ('abc', 123, (1, 2), [22, 33, 44, "ttt"])
for item in tuple1:
print(item)
輸出：
abc 123 (1, 2) [22, 33, 44, 'ttt']
5、字典：dict
字典的建立：
person = {"name": "zjs", 'age': 12}
或
person = dict({"name": "zjs", 'age': 12})
字典中的元素是無序的
（1）字典的常用方法：
1.clear(self) ---->清空字典內所有鍵值對與列表相同
引數：無
返回值：無
>>> aDict = {'name': 'zjs', 'age':12, 'sex':'male'}
>>> aDict.clear()
>>> print(aDict)
{}2.copy(self) ---->對字典的淺拷貝與列表相同
引數：無
返回值：字典
>>> aDict = {'name': 'zjs', 'age':12, 'sex':'male'}
>>> bDict = aDict.copy()
>>> print(aDict,bDict)
{'sex': 'male', 'age': 12, 'name': 'zjs'} {'sex': 'male', 'age': 12, 'name': 'zjs'}
3.keys(self) ---->以列表方式返回字典的所有鍵
引數：無
返回值：dict_keys
>>> aDict = {'name': 'zjs', 'age':12, 'sex':'male'}
>>> print(aDict.keys())
dict_keys(['sex', 'age', 'name'])
4.values(self) ---->與keys類似，返回字典的所有值
引數：無
返回值：dict_values
>>> aDict = {'name': 'zjs', 'age':12, 'sex':'male'}
>>> print(aDict.values())
dict_values(['male', 12, 'zjs'])
5.items(self) ---->以列表的方式返回字典的鍵值對 每個鍵值對用元祖表示
引數：無
返回值：dict_items
>>> aDict = {'name': 'zjs', 'age':12, 'sex':'male'}
>>> print(aDict.items())
dict_items([('sex', 'male'), ('age', 12), ('name', 'zjs')])
6.get(self, k, d=None) ---->獲得字典指定鍵的值
引數：
k：指定的鍵
d：如果指定鍵的值不存在時，返回該預設值值。
返回值：無
aDict = {'name': 'zjs', 'age': 12, 'sex': 'male'}
name = aDict.get('name')
grade = aDict.get('grade', 3)
print(name,grade)
輸出：
zjs 3
7.update(self, E=None, **F) ---->新增指定字典到該字典內如果字典內有該鍵則更新這個值
引數：
E：傳入字典
**F：傳入若干關鍵字
返回值：無
aDict = {'name': 'zjs', 'age': 12, 'sex': 'male'}
aDict.update({'grade': 3}) #傳入字典
print(aDict)
aDict.update(age = 5, six=6) #傳入關鍵字
print(aDict)
輸出：
{'sex': 'male', 'age': 12, 'name': 'zjs', 'grade': 3}
{'six': 6, 'sex': 'male', 'age': 5, 'name': 'zjs', 'grade': 3}
8.pop(self, k, d=None) ---->刪除字典中指定的 鍵值對 k和與其對應的value並返回這個鍵 若k不存在則返回指定的d
引數：
k：刪除指定的k
d：若k不存在時候返回預設的d
返回值：數字/字串/字典/列表/元祖/.../
aDict = {'name': 'zjs', 'age': 12, 'sex': 'male'}
a = aDict.pop('name')
print(a, aDict)
b = aDict.pop('grade',3)
print(b, aDict)
輸出：
zjs {'sex': 'male', 'age': 12}
3 {'sex': 'male', 'age': 12}
9.popitem(self) ---->隨機刪除字典中的鍵值對（通常刪除末尾鍵值對）
引數：無
返回值：元祖
>>> aDict = {'name': 'zjs', 'age': 12, 'sex': 'male'}
>>> aDict.popitem()
('sex', 'male')
>>> print(aDict)
{'name': 'zjs', 'age': 12}
10.setdefault(self, k, d=None) ---->設定k的預設值如果d未指定則預設為None
引數：無
返回值：無
>>> aDict = {'name': 'zjs', 'age': 12, 'sex': 'male'}
>>> aDict.setdefault('a')
>>> print(aDict)
{'name': 'zjs', 'age': 12, 'sex': 'male', 'a': None}
11.fromkeys(*args, **kwargs) @staticmethod ---->fromkeys()為靜態方法，可以不宣告物件直接呼叫
引數：任意
返回值：字典
seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq)
print ("新的字典為 : %s" % str(dict))
dict = dict.fromkeys(seq, 10)
print ("新的字典為 : %s" % str(dict))
輸出：
新的字典為 : {'age': None, 'name': None, 'sex': None}
新的字典為 : {'age': 10, 'name': 10, 'sex': 10}
（2）訪問字典裡的值
由於字典中的鍵值對是無序的。所以不能使用下標來訪問字典內的值，只能通過鍵來查詢所對應的值
aDict = {'name': 'zjs', 'age': 12, 's