其實是最近變懶了，該考慮一下更自律一點了
參考自以下
Python系列_礁之的博客-CSDN博客
主要為對之前所學(xué)內(nèi)容的總結(jié)以及拓展學(xué)習(xí)，包含python·基礎(chǔ)內(nèi)容，函數(shù)，及面向?qū)ο缶幊?/p>
文章目錄
一、 Python變量與數(shù)據(jù)類型
1.變量概述
2.創(chuàng)建變量
3.Python3常用的數(shù)據(jù)類型
3.1.數(shù)字（Numbers）
3.2.字符串（String）
3.3.列表（list）
3.4.元組（Tuple）
3.5.集合（Set）
3.6.字典（Dictionary）
3.7.Python數(shù)據(jù)類型轉(zhuǎn)換
4.Python3基礎(chǔ)語法
4.1.編碼
4.2.標(biāo)識符
4.3.Python保留字
4.3.注釋
4.4.行與縮進(jìn)
4.5.多行語句
4.6.空行
4.7.等待用戶輸入
4.8.同一行顯示多條語句
4.9.多個語句構(gòu)成代碼組
4.10.print輸出
4.11.import和from...import
4.12.命令行參數(shù)
二、拓展小腳本
-選車牌小程序
-99乘法表
- 年會抽獎小程序
一、 Python變量與數(shù)據(jù)類型
Python是一種動態(tài)解釋型的編程語言
要想使用python，可以使用python自帶的IDLE編輯器，也可以下載PyCharm、VScode等
1.變量概述
變量是存儲在內(nèi)存中的值，而這就意味著在創(chuàng)建變量時會在內(nèi)存中開辟一個空間基于變量的數(shù)據(jù)類型，解釋器會分配指定內(nèi)存，并決定什么數(shù)據(jù)可以被存儲在內(nèi)存中，因此，變量可以指定不同的數(shù)據(jù)類型，如字符串、數(shù)字、列表、字典甚至函數(shù)
變量名是由字母、數(shù)字、下劃線組成的，第一個字符必須是字母或者下劃線_
使用變量可以提高代碼的可讀性，便于修改
Python中的變量賦值不需要類似聲明，每個變量都在內(nèi)存中創(chuàng)建，包括變量的的標(biāo)識、名稱、數(shù)據(jù)等信息，每個變量在使用前都必須賦值，變量賦值以后這個變量才會被創(chuàng)建
在Python中“=”用來給變量賦值，變量名=變量值，例如：
a = "hello world"
print(a)
hello world
1
2
3
2.創(chuàng)建變量
創(chuàng)建合法的變量名稱
a =1
print(a) #print()是打印，即shell中的echo
1
_a =2
print(_a)
2
a1 = 3
print(a1)
3
可以同時指定多個變量名進(jìn)行賦值
a,b,c = 1,2,3
print(a)
1
print(b,c)
2 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
3.Python3常用的數(shù)據(jù)類型
類型 作用
數(shù)字（Numbers） 數(shù)字類型數(shù)據(jù)用于存儲數(shù)值，他們是不可改變的數(shù)據(jù)類型，這意味著改變數(shù)字類型會分配一個新的對象，當(dāng)你指定一個值時，Numbers類型的對象就會被創(chuàng)建，數(shù)字類型在輸入時，直接輸入數(shù)字即可，如55，無需加引號等
字符串（String） 字符串或串是由數(shù)字、字母、下劃線組成的一串字符，在給變量賦值時加雙引號" "或單引號' '就是字符串類型
列表（List） Python中使用最頻繁的數(shù)據(jù)類型，列表可以完成大多數(shù)集合類的數(shù)據(jù)結(jié)構(gòu)，支持字符、數(shù)字、字符串，也可以嵌套，在列表中包含列表，使用`[ ]創(chuàng)建列表
元組（Tuple） 元組是另一個數(shù)據(jù)類型，類似于列表，但是不能二次賦值，相當(dāng)于只讀列表，使用（）創(chuàng)建元組
字典（Dictionary） 字典是除了列表以外，Python中最靈活的內(nèi)置數(shù)據(jù)結(jié)構(gòu)類型，使用{ }創(chuàng)建字典
列表是有序的對象集合，而字典是無序的對象集合
兩者的區(qū)別在于：
（1）字典中的元素是通過鍵來存取的，也就是鍵值對的方式Key-Value，而不是通過偏移存取
（2）列表只是簡單的存放多個變量值，字典相當(dāng)于是"在字典中又創(chuàng)建了變量"
還有一種類型是集合（set），集合是無序的對象集合，集合中沒有重復(fù)的元素，通常用來去重等，使用{ }來創(chuàng)建，不過和字典不同的是不需要使用：來定義key和value，與列表一樣的去定義元素即可
3.1.數(shù)字（Numbers）
3.1.1.數(shù)字的數(shù)據(jù)類型也分成了很多種類型：
整型(int)： 也就是整數(shù)
浮點型(float)： 帶小數(shù)點的數(shù)字
布爾型(bool)： 用于邏輯運(yùn)算，只有true和false，即真和假
復(fù)數(shù)(complex)： 復(fù)數(shù)由實部（real）和虛部（imag）構(gòu)成，在 Python 中，復(fù)數(shù)的虛部以j或者J作為后綴，,如1+2j、1.1+2.2J
3.1.2.Python運(yùn)算符：
算法 運(yùn)算符
加法 +
減法 -
乘法 *
除法 /
求模，取余 %
求冪，即求次方，2**2即2的2次方 **
先乘除后加減，有小括號就先算小括號，注意：Python是不支持自增運(yùn)算符++和自減運(yùn)算符–的
3.1.3.整型、浮點型、布爾型
x = 123 #整型
print(x)
123
y = 1.12 #浮點型
print(y)
1.12
a = True #布爾型true
print(a)
print(a)
hello world
1
2
3
2.創(chuàng)建變量
#創(chuàng)建合法的變量名稱
>>> a =1
>>>print(a) #print()是打印，即shell中的echo
1
>>> _a =2
>>> print(_a)
2
>>> a1 = 3
>>> print(a1)
3
#可以同時指定多個變量名進(jìn)行賦值
>>> a,b,c = 1,2,3
>>> print(a)
1
>>> print(b,c)
2 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
3.Python3常用的數(shù)據(jù)類型
類型 作用
數(shù)字（Numbers） 數(shù)字類型數(shù)據(jù)用于存儲數(shù)值，他們是不可改變的數(shù)據(jù)類型，這意味著改變數(shù)字類型會分配一個新的對象，當(dāng)你指定一個值時，Numbers類型的對象就會被創(chuàng)建，數(shù)字類型在輸入時，直接輸入數(shù)字即可，如55，無需加引號等
字符串（String） 字符串或串是由數(shù)字、字母、下劃線組成的一串字符，在給變量賦值時加雙引號" "或單引號' '就是字符串類型
列表（List） Python中使用最頻繁的數(shù)據(jù)類型，列表可以完成大多數(shù)集合類的數(shù)據(jù)結(jié)構(gòu)，支持字符、數(shù)字、字符串，也可以嵌套，在列表中包含列表，使用[ ]創(chuàng)建列表 元組（Tuple） 元組是另一個數(shù)據(jù)類型，類似于列表，但是不能二次賦值，相當(dāng)于只讀列表，使用（）創(chuàng)建元組 字典（Dictionary） 字典是除了列表以外，Python中最靈活的內(nèi)置數(shù)據(jù)結(jié)構(gòu)類型，使用{ }創(chuàng)建字典 列表是有序的對象集合，而字典是無序的對象集合 兩者的區(qū)別在于： （1）字典中的元素是通過鍵來存取的，也就是鍵值對的方式Key-Value，而不是通過偏移存取 （2）列表只是簡單的存放多個變量值，字典相當(dāng)于是"在字典中又創(chuàng)建了變量" 還有一種類型是集合（set），集合是無序的對象集合，集合中沒有重復(fù)的元素，通常用來去重等，使用{ }來創(chuàng)建，不過和字典不同的是不需要使用：來定義key和value，與列表一樣的去定義元素即可 3.1.數(shù)字（Numbers） 3.1.1.數(shù)字的數(shù)據(jù)類型也分成了很多種類型： 整型(int)： 也就是整數(shù) 浮點型(float)： 帶小數(shù)點的數(shù)字 布爾型(bool)： 用于邏輯運(yùn)算，只有true和false，即真和假 復(fù)數(shù)(complex)： 復(fù)數(shù)由實部（real）和虛部（imag）構(gòu)成，在 Python 中，復(fù)數(shù)的虛部以j或者J作為后綴，,如1+2j、1.1+2.2J 3.1.2.Python運(yùn)算符： 算法 運(yùn)算符 加法 + 減法 - 乘法 * 除法 / 求模，取余 % 求冪，即求次方，2**2即2的2次方 ** 先乘除后加減，有小括號就先算小括號，注意：Python是不支持自增運(yùn)算符++和自減運(yùn)算符–的 3.1.3.整型、浮點型、布爾型 >>> x = 123 #整型 >>> print(x) 123 >>> y = 1.12 #浮點型 >>> print(y) 1.12 >>> a = True #布爾型true >>> print(a) True if(a): #使用if語句反段，符合if語句的條件，就輸出下面的語句，因為a為布爾型true，所以始終為真，也就是始終符合條件 ... print("為真") ... _a =2 >>> print(_a) 2 >>> a1 = 3 >>> print(a1) 3 #可以同時指定多個變量名進(jìn)行賦值 >>> a,b,c = 1,2,3 >>> print(a) 1 >>> print(b,c) 2 3 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 3.Python3常用的數(shù)據(jù)類型 類型 作用 數(shù)字（Numbers） 數(shù)字類型數(shù)據(jù)用于存儲數(shù)值，他們是不可改變的數(shù)據(jù)類型，這意味著改變數(shù)字類型會分配一個新的對象，當(dāng)你指定一個值時，Numbers類型的對象就會被創(chuàng)建，數(shù)字類型在輸入時，直接輸入數(shù)字即可，如55，無需加引號等 字符串（String） 字符串或串是由數(shù)字、字母、下劃線組成的一串字符，在給變量賦值時加雙引號" "或單引號' '就是字符串類型 列表（List） Python中使用最頻繁的數(shù)據(jù)類型，列表可以完成大多數(shù)集合類的數(shù)據(jù)結(jié)構(gòu)，支持字符、數(shù)字、字符串，也可以嵌套，在列表中包含列表，使用[ ]創(chuàng)建列表
元組（Tuple） 元組是另一個數(shù)據(jù)類型，類似于列表，但是不能二次賦值，相當(dāng)于只讀列表，使用（）創(chuàng)建元組
字典（Dictionary） 字典是除了列表以外，Python中最靈活的內(nèi)置數(shù)據(jù)結(jié)構(gòu)類型，使用{ }創(chuàng)建字典
列表是有序的對象集合，而字典是無序的對象集合
兩者的區(qū)別在于：
（1）字典中的元素是通過鍵來存取的，也就是鍵值對的方式Key-Value，而不是通過偏移存取
（2）列表只是簡單的存放多個變量值，字典相當(dāng)于是"在字典中又創(chuàng)建了變量"
還有一種類型是集合（set），集合是無序的對象集合，集合中沒有重復(fù)的元素，通常用來去重等，使用{ }來創(chuàng)建，不過和字典不同的是不需要使用：來定義key和value，與列表一樣的去定義元素即可
3.1.數(shù)字（Numbers）
3.1.1.數(shù)字的數(shù)據(jù)類型也分成了很多種類型：
整型(int)： 也就是整數(shù)
浮點型(float)： 帶小數(shù)點的數(shù)字
布爾型(bool)： 用于邏輯運(yùn)算，只有true和false，即真和假
復(fù)數(shù)(complex)： 復(fù)數(shù)由實部（real）和虛部（imag）構(gòu)成，在 Python 中，復(fù)數(shù)的虛部以j或者J作為后綴，,如1+2j、1.1+2.2J
3.1.2.Python運(yùn)算符：
算法 運(yùn)算符
加法 +
減法 -
乘法 *
除法 /
求模，取余 %
求冪，即求次方，2**2即2的2次方 **
先乘除后加減，有小括號就先算小括號，注意：Python是不支持自增運(yùn)算符++和自減運(yùn)算符–的
3.1.3.整型、浮點型、布爾型
>>> x = 123 #整型
>>> print(x)
123
>>> y = 1.12 #浮點型
>>> print(y)
1.12
>>> a = True #布爾型true
>>> print(a)
True
>>>if(a): #使用if語句反段，符合if語句的條件，就輸出下面的語句，因為a為布爾型true，所以始終為真，也就是始終符合條件
... print("為真")
...
為真
b = False #布爾型false
if(b): #如果b符合條件，則輸出為真，否則輸出為假，因為b是布爾型false，所以始終為假，也就是始終為假
... print("為真")
... else:
... print("為假")
...
為假
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
3.1.4.變量標(biāo)識符
變量標(biāo)識符就像是變量的“身份證”，具有唯一性
print(id(x)) #查看x變量的標(biāo)識符
2774440106160
print(id(y)) #查看y變量的標(biāo)識符
2774486777776
1
2
3
4
5
3.1.5.Python運(yùn)算符
x,y = 2,4 #賦值變量x和y的值分別是2和4
print(x+y,y-x,x*y) #加、減、乘算法
6 2 8
print(4/2,2**4) #除、求冪算法
2.0 16
print(8%5) #取余算法，8除5余3
3
1
2
3
4
5
6
7
8
9
3.2.字符串（String）
python中單引號和雙引號使用完全相同
使用三引號''' 或 """)可以指定一個多行字符串
轉(zhuǎn)義符
反斜杠可以用來轉(zhuǎn)義，使用r可以讓反斜杠不發(fā)生轉(zhuǎn)義,如 r"this is a line with \n" 則\n會作為普通字符顯示，而不是作為換行符
按字面意義級聯(lián)字符串，如"this " "is " "string"會被自動轉(zhuǎn)換為this is string
字符串可以用 + 運(yùn)算符連接在一起，用 * 運(yùn)算符重復(fù)
Python 中的字符串有兩種索引方式，從左往右以 0 開始，從右往左以 -1 開始，與列表相同
Python中的字符串不能改變
Python 沒有單獨的字符類型，一個字符就是長度為 1 的字符串
3.2.1.單引號、雙引號、三引號
name = '亞索' #單引號
print(name)
亞索
age = "34歲" #雙引號
print(age)
34歲
aihao = """ #三引號
耍劍
喝酒
"""
print(aihao)
耍劍
喝酒
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
3.2.2.轉(zhuǎn)義符
aaa = "aa'gao'"
print(aaa)
aa'gao'
bbb = ' aaa"ccc"'
print(bbb)
aaa"ccc"
ccc = 'abc'ccc' #轉(zhuǎn)義'為普通字符
print(ccc)
abc'ccc
1
2
3print(a)
True
>>>if(a): #使用if語句反段，符合if語句的條件，就輸出下面的語句，因為a為布爾型true，所以始終為真，也就是始終符合條件
... print("為真")
...
為真
>>> b = False #布爾型false
>>> if(b): #如果b符合條件，則輸出為真，否則輸出為假，因為b是布爾型false，所以始終為假，也就是始終為假
... print("為真")
... else:
... print("為假")
...
為假
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
3.1.4.變量標(biāo)識符
變量標(biāo)識符就像是變量的“身份證”，具有唯一性
>>> print(id(x)) #查看x變量的標(biāo)識符
2774440106160
>>> print(id(y)) #查看y變量的標(biāo)識符
2774486777776
1
2
3
4
5
3.1.5.Python運(yùn)算符
>>> x,y = 2,4 #賦值變量x和y的值分別是2和4
>>> print(x+y,y-x,xy) #加、減、乘算法
6 2 8
>>> print(4/2,24) #除、求冪算法
2.0 16
>>> print(8%5) #取余算法，8除5余3
3
1
2
3
4
5
6
7
8
9
3.2.字符串（String）
python中單引號和雙引號使用完全相同
使用三引號''' 或 """)可以指定一個多行字符串
轉(zhuǎn)義符
反斜杠可以用來轉(zhuǎn)義，使用r可以讓反斜杠不發(fā)生轉(zhuǎn)義,如 r"this is a line with \n" 則\n會作為普通字符顯示，而不是作為換行符
按字面意義級聯(lián)字符串，如"this " "is " "string"會被自動轉(zhuǎn)換為this is string
字符串可以用 + 運(yùn)算符連接在一起，用 * 運(yùn)算符重復(fù)
Python 中的字符串有兩種索引方式，從左往右以 0 開始，從右往左以 -1 開始，與列表相同
Python中的字符串不能改變
Python 沒有單獨的字符類型，一個字符就是長度為 1 的字符串
3.2.1.單引號、雙引號、三引號
>>> name = '亞索' #單引號
>>> print(name)
亞索
>>> age = "34歲" #雙引號
>>> print(age)
34歲
>>> aihao = """ #三引號
耍劍
喝酒
"""
>>> print(aihao)
耍劍
喝酒
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
3.2.2.轉(zhuǎn)義符
>>> aaa = "aa'gao'"
>>> print(aaa)
aa'gao'
>>> bbb = ' aaa"ccc"'
>>> print(bbb)
aaa"ccc"
>>> ccc = 'abc'ccc' #轉(zhuǎn)義'為普通字符
>>> print(ccc)
abc'ccc
1
2
3
4
print(a)
True
>>>if(a): #使用if語句反段，符合if語句的條件，就輸出下面的語句，因為a為布爾型true，所以始終為真，也就是始終符合條件
... print("為真")
...
為真
>>> b = False #布爾型false
>>> if(b): #如果b符合條件，則輸出為真，否則輸出為假，因為b是布爾型false，所以始終為假，也就是始終為假
... print("為真")
... else:
... print("為假")
...
為假
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
3.1.4.變量標(biāo)識符
變量標(biāo)識符就像是變量的“身份證”，具有唯一性
>>> print(id(x)) #查看x變量的標(biāo)識符
2774440106160
>>> print(id(y)) #查看y變量的標(biāo)識符
2774486777776
1
2
3
4
5
3.1.5.Python運(yùn)算符
>>> x,y = 2,4 #賦值變量x和y的值分別是2和4
>>> print(x+y,y-x,xy) #加、減、乘算法
6 2 8
>>> print(4/2,2**4) #除、求冪算法
2.0 16
>>> print(8%5) #取余算法，8除5余3
3
1
2
3
4
5
6
7
8
9
3.2.字符串（String）
python中單引號和雙引號使用完全相同
使用三引號''' 或 """)可以指定一個多行字符串
轉(zhuǎn)義符
反斜杠可以用來轉(zhuǎn)義，使用r可以讓反斜杠不發(fā)生轉(zhuǎn)義,如 r"this is a line with \n" 則\n會作為普通字符顯示，而不是作為換行符
按字面意義級聯(lián)字符串，如"this " "is " "string"會被自動轉(zhuǎn)換為this is string
字符串可以用 + 運(yùn)算符連接在一起，用 * 運(yùn)算符重復(fù)
Python 中的字符串有兩種索引方式，從左往右以 0 開始，從右往左以 -1 開始，與列表相同
Python中的字符串不能改變
Python 沒有單獨的字符類型，一個字符就是長度為 1 的字符串
3.2.1.單引號、雙引號、三引號
>>> name = '亞索' #單引號
>>> print(name)
亞索
>>> age = "34歲" #雙引號
>>> print(age)
34歲
>>> aihao = """ #三引號
耍劍
喝酒
"""
>>> print(aihao)
耍劍
喝酒
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
3.2.2.轉(zhuǎn)義符
>>> aaa = "aa'gao'"
>>> print(aaa)
aa'gao'
>>> bbb = ' aaa"ccc"'
>>> print(bbb)
aaa"ccc"
>>> ccc = 'abc'ccc' #轉(zhuǎn)義'為普通字符
>>> print(ccc)
abc'ccc
1
2
3
4
5
6
7
8
9
3.2.3.常用轉(zhuǎn)義符
轉(zhuǎn)義符 作用
\ 在行尾時使用，為續(xù)航符，也就是換行符
\ 這個含義是指把\轉(zhuǎn)義成普通字符
\’ 把’轉(zhuǎn)義成普通字符
" 把“轉(zhuǎn)義成普通字符
\n 換行符，把光標(biāo)移動到下一行繼續(xù)
\v 縱向制表符，將光標(biāo)向下移動一個制表符單位
\t 水平制表符，將光標(biāo)向右移動一個制表符單位
\r 代表一個回車
3.2.4.字符串的其他用法
+號可以當(dāng)作字符串的連接字符，而*號可以是重復(fù)操作
print("aaa" + "bbb")
aaabbb
print(3*"aaa")
aaaaaaaaa
新建一個新的.py文件，寫入：
a = ' '
print("歡迎來到，英雄聯(lián)盟")
print(a2+"歡迎來到，英雄聯(lián)盟")
print(a4+"歡迎來到，英雄聯(lián)盟")
歡迎來到，英雄聯(lián)盟
歡迎來到，英雄聯(lián)盟
歡迎來到，英雄聯(lián)盟
a為一個空，利用*號可以使空重復(fù)操作變成多個，然后就可以實現(xiàn)上面的效果
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
3.3.列表（list）
3.3.1.列表的定義
列表其實就是一個變量有多個變量值，但是這個變量值叫做元素，所以也叫做，一個列表中有多個元素，使用[]來表示列表
a = ["1","2","3"]
print(a)
['1', '2', '3']
1
2
3
4
3.3.2列表的取值
列表有兩種取值順序：
1.從左到右索引默認(rèn)從0開始，最大范圍是字符串長度-1，這個0和shell的位置變量有點像
2.從右到左的索引默認(rèn)從-1開始，最大范圍是字符串開頭
a = ["1","2","3"]
print(a)
['1', '2', '3']
print(a[0])
1
print(a[1])
2
print(a[2])
3
print(a[-1])
3
print(a[-2])
2
print(a[-3])
1
print(a[0:2]) #從0開始到2位置結(jié)束
['1', '2']
print(a[0:3])
['1', '2', '3']
print(a[0:1])
['1']
a[0]=4 #修改a列表中0位置為4
print(a)
[4, '2', '3']
a.append(5) #在a列表末尾添加5
print(a)
[4, '2', '3', 5]
a.insert(1,6) #在a列表的1位置后添加6
print(a)
[4, 6, '2', '3', 5]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
3.3.3.刪除列表元素
print(a)
[4, 6, '2', '3', 5]
del a[0] #刪除a列表中的0位置的元素
print(a)
[6, '2', '3', 5]
1
2
3
4
5
3.3.4.查找列表元素
print(a)
[6, '2', '3', 5]
6 in a #查看a列表中是否有6，有就返回True沒有就返回False
True
8 in a
False
1
2
3
4
5
6
3.3.5.合并列表
a = ["nihao","shijie"]
b = ["hello","world"]
c = a + b #利用+號，來合并列表，變量也可以這樣使用
print(c)
['nihao', 'shijie', 'hello', 'world']
d = b + a
print(d)
['hello', 'world', 'nihao', 'shijie']
print(a3) #利用號，來重復(fù)列表
['nihao', 'shijie', 'nihao', 'shijie', 'nihao', 'shijie']
1
2
3
4
5
6
7
8
9
10
3.3.6.列表常見問題
print(a)
[1, 2, 3]
print(a[6]) #不能直接查看超過列表元素總數(shù)的值
Traceback (most recent call last):
File "<input>", line 1, in <module>
IndexError: list index out of range
print(a[1:6]) #但是可以指定范圍查看
[2, 3]
print(a[0:-1]) #指定范圍時，可以同時使用正數(shù)和負(fù)數(shù)進(jìn)行索引
[1, 2]
1
2
3
4
5print(a[0])
1
>>> print(a[1])
2
>>> print(a[2])
3
>>> print(a[-1])
3
>>> print(a[-2])
2
>>> print(a[-3])
1
>>> print(a[0:2]) #從0開始到2位置結(jié)束
['1', '2']
>>> print(a[0:3])
['1', '2', '3']
>>> print(a[0:1])
['1']
>>> a[0]=4 #修改a列表中0位置為4
>>> print(a)
[4, '2', '3']
>>> a.append(5) #在a列表末尾添加5
>>> print(a)
[4, '2', '3', 5]
>>> a.insert(1,6) #在a列表的1位置后添加6
>>> print(a)
[4, 6, '2', '3', 5]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
3.3.3.刪除列表元素
>>> print(a)
[4, 6, '2', '3', 5]
>>> del a[0] #刪除a列表中的0位置的元素
>>> print(a)
[6, '2', '3', 5]
1
2
3
4
5
3.3.4.查找列表元素
>>> print(a)
[6, '2', '3', 5]
>>> 6 in a #查看a列表中是否有6，有就返回True沒有就返回False
True
>>> 8 in a
False
1
2
3
4
5
6
3.3.5.合并列表
>>> a = ["nihao","shijie"]
>>> b = ["hello","world"]
>>> c = a + b #利用+號，來合并列表，變量也可以這樣使用
>>> print(c)
['nihao', 'shijie', 'hello', 'world']
>>> d = b + a
>>> print(d)
['hello', 'world', 'nihao', 'shijie']
>>> print(a3) #利用號，來重復(fù)列表
['nihao', 'shijie', 'nihao', 'shijie', 'nihao', 'shijie']
1
2
3
4
5
6
7
8
9
10
3.3.6.列表常見問題
>>> print(a)
[1, 2, 3]
>>> print(a[6]) #不能直接查看超過列表元素總數(shù)的值
Traceback (most recent call last):
File "<input>", line 1, in <module>
IndexError: list index out of range
>>> print(a[1:6]) #但是可以指定范圍查看
[2, 3]
>>> print(a[0:-1]) #指定范圍時，可以同時使用正數(shù)和負(fù)數(shù)進(jìn)行索引
[1, 2]
1
2
3
4
5
6
print(a[0])
1
>>> print(a[1])
2
>>> print(a[2])
3
>>> print(a[-1])
3
>>> print(a[-2])
2
>>> print(a[-3])
1
>>> print(a[0:2]) #從0開始到2位置結(jié)束
['1', '2']
>>> print(a[0:3])
['1', '2', '3']
>>> print(a[0:1])
['1']
>>> a[0]=4 #修改a列表中0位置為4
>>> print(a)
[4, '2', '3']
>>> a.append(5) #在a列表末尾添加5
>>> print(a)
[4, '2', '3', 5]
>>> a.insert(1,6) #在a列表的1位置后添加6
>>> print(a)
[4, 6, '2', '3', 5]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
3.3.3.刪除列表元素
>>> print(a)
[4, 6, '2', '3', 5]
>>> del a[0] #刪除a列表中的0位置的元素
>>> print(a)
[6, '2', '3', 5]
1
2
3
4
5
3.3.4.查找列表元素
>>> print(a)
[6, '2', '3', 5]
>>> 6 in a #查看a列表中是否有6，有就返回True沒有就返回False
True
>>> 8 in a
False
1
2
3
4
5
6
3.3.5.合并列表
>>> a = ["nihao","shijie"]
>>> b = ["hello","world"]
>>> c = a + b #利用+號，來合并列表，變量也可以這樣使用
>>> print(c)
['nihao', 'shijie', 'hello', 'world']
>>> d = b + a
>>> print(d)
['hello', 'world', 'nihao', 'shijie']
>>> print(a3) #利用號，來重復(fù)列表
['nihao', 'shijie', 'nihao', 'shijie', 'nihao', 'shijie']
1
2
3
4
5
6
7
8
9
10
3.3.6.列表常見問題
>>> print(a)
[1, 2, 3]
>>> print(a[6]) #不能直接查看超過列表元素總數(shù)的值
Traceback (most recent call last):
File "<input>", line 1, in <module>
IndexError: list index out of range
>>> print(a[1:6]) #但是可以指定范圍查看
[2, 3]
>>> print(a[0:-1]) #指定范圍時，可以同時使用正數(shù)和負(fù)數(shù)進(jìn)行索引
[1, 2]
1
2
3
4
5
6
7
8
9
10
3.3.7.嵌套列表
列表中也可以是列表，是可以無限嵌套的
a = [[1,2,3],"aaa",[4,5,6]]
print(a)
[[1, 2, 3], 'aaa', [4, 5, 6]]
print(a[0]) #查看a列表中的第0個位置的元素
[1, 2, 3]
print(a[0][0]) #查看a列表中第0個位置元素的第0個位置的元素
1
1
2a[0]=4 #修改a列表中0位置為4
>>> print(a)
[4, '2', '3']
>>> a.append(5) #在a列表末尾添加5
>>> print(a)
[4, '2', '3', 5]
>>> a.insert(1,6) #在a列表的1位置后添加6
>>> print(a)
[4, 6, '2', '3', 5]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
3.3.3.刪除列表元素
>>> print(a)
[4, 6, '2', '3', 5]
>>> del a[0] #刪除a列表中的0位置的元素
>>> print(a)
[6, '2', '3', 5]
1
2
3
4
5
3.3.4.查找列表元素
>>> print(a)
[6, '2', '3', 5]
>>> 6 in a #查看a列表中是否有6，有就返回True沒有就返回False
True
>>> 8 in a
False
1
2
3
4
5
6
3.3.5.合并列表
>>> a = ["nihao","shijie"]
>>> b = ["hello","world"]
>>> c = a + b #利用+號，來合并列表，變量也可以這樣使用
>>> print(c)
['nihao', 'shijie', 'hello', 'world']
>>> d = b + a
>>> print(d)
['hello', 'world', 'nihao', 'shijie']
>>> print(a3) #利用號，來重復(fù)列表
['nihao', 'shijie', 'nihao', 'shijie', 'nihao', 'shijie']
1
2
3
4
5
6
7
8
9
10
3.3.6.列表常見問題
>>> print(a)
[1, 2, 3]
>>> print(a[6]) #不能直接查看超過列表元素總數(shù)的值
Traceback (most recent call last):
File "<input>", line 1, in <module>
IndexError: list index out of range
>>> print(a[1:6]) #但是可以指定范圍查看
[2, 3]
>>> print(a[0:-1]) #指定范圍時，可以同時使用正數(shù)和負(fù)數(shù)進(jìn)行索引
[1, 2]
1
2
3
4
5
6
7
8
9
10
3.3.7.嵌套列表
#列表中也可以是列表，是可以無限嵌套的
>>> a = [[1,2,3],"aaa",[4,5,6]]
>>> print(a)
[[1, 2, 3], 'aaa', [4, 5, 6]]
>>> print(a[0]) #查看a列表中的第0個位置的元素
[1, 2, 3]
>>> print(a[0][0]) #查看a列表中第0個位置元素的第0個位置的元素
1
1
2
3name = '亞索' #單引號
>>> print(name)
亞索
>>> age = "34歲" #雙引號
>>> print(age)
34歲
>>> aihao = """ #三引號
耍劍
喝酒
"""
>>> print(aihao)
耍劍
喝酒
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
3.2.2.轉(zhuǎn)義符
>>> aaa = "aa'gao'"
>>> print(aaa)
aa'gao'
>>> bbb = ' aaa"ccc"'
>>> print(bbb)
aaa"ccc"
>>> ccc = 'abc'ccc' #轉(zhuǎn)義'為普通字符
>>> print(ccc)
abc'ccc
1
2
3
4
5
6
7
8
9
3.2.3.常用轉(zhuǎn)義符
轉(zhuǎn)義符 作用
\ 在行尾時使用，為續(xù)航符，也就是換行符
\ 這個含義是指把\轉(zhuǎn)義成普通字符
\’ 把’轉(zhuǎn)義成普通字符
" 把“轉(zhuǎn)義成普通字符
\n 換行符，把光標(biāo)移動到下一行繼續(xù)
\v 縱向制表符，將光標(biāo)向下移動一個制表符單位
\t 水平制表符，將光標(biāo)向右移動一個制表符單位
\r 代表一個回車
3.2.4.字符串的其他用法
#+號可以當(dāng)作字符串的連接字符，而號可以是重復(fù)操作
>>> print("aaa" + "bbb")
aaabbb
>>> print(3"aaa")
aaaaaaaaa
#新建一個新的.py文件，寫入：
a = ' '
print("歡迎來到，英雄聯(lián)盟")
print(a2+"歡迎來到，英雄聯(lián)盟")
print(a4+"歡迎來到，英雄聯(lián)盟")
歡迎來到，英雄聯(lián)盟
歡迎來到，英雄聯(lián)盟
歡迎來到，英雄聯(lián)盟
#a為一個空，利用號可以使空重復(fù)操作變成多個，然后就可以實現(xiàn)上面的效果
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
3.3.列表（list）
3.3.1.列表的定義
#列表其實就是一個變量有多個變量值，但是這個變量值叫做元素，所以也叫做，一個列表中有多個元素，使用[]來表示列表
>>> a = ["1","2","3"]
>>> print(a)
['1', '2', '3']
1
2
3
4
3.3.2列表的取值
#列表有兩種取值順序：
1.從左到右索引默認(rèn)從0開始，最大范圍是字符串長度-1，這個0和shell的位置變量有點像
2.從右到左的索引默認(rèn)從-1開始，最大范圍是字符串開頭
>>> a = ["1","2","3"]
>>> print(a)
['1', '2', '3']
>>> print(a[0])
1
>>> print(a[1])
2
>>> print(a[2])
3
>>> print(a[-1])
3
>>> print(a[-2])
2
>>> print(a[-3])
1
>>> print(a[0:2]) #從0開始到2位置結(jié)束
['1', '2']
>>> print(a[0:3])
['1', '2', '3']
>>> print(a[0:1])
['1']
>>> a[0]=4 #修改a列表中0位置為4
>>> print(a)
[4, '2', '3']
>>> a.append(5) #在a列表末尾添加5
>>> print(a)
[4, '2', '3', 5]
>>> a.insert(1,6) #在a列表的1位置后添加6
>>> print(a)
[4, 6, '2', '3', 5]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
3.3.3.刪除列表元素
>>> print(a)
[4, 6, '2', '3', 5]
>>> del a[0] #刪除a列表中的0位置的元素
>>> print(a)
[6, '2', '3', 5]
1
2
3
4
5
3.3.4.查找列表元素
>>> print(a)
[6, '2', '3', 5]
>>> 6 in a #查看a列表中是否有6，有就返回True沒有就返回False
True
>>> 8 in a
False
1
2
3
4
5
6
3.3.5.合并列表
>>> a = ["nihao","shijie"]
>>> b = ["hello","world"]
>>> c = a + b #利用+號，來合并列表，變量也可以這樣使用
>>> print(c)
['nihao', 'shijie', 'hello', 'world']
>>> d = b + a
>>> print(d)
['hello', 'world', 'nihao', 'shijie']
>>> print(a3) #利用*號，來重復(fù)列表
['nihao', 'shijie', 'nihao', 'shijie', 'nihao', 'shijie']
1
2
3
4
5
6
7
8
9
10
3.3.6.列表常見問題
>>> print(a)
[1, 2, 3]
>>> print(a[6]) #不能直接查看超過列表元素總數(shù)的值
Traceback (most recent call last):
File "<input>", line 1, in <module>
IndexError: list index out of range
>>> print(a[1:6]) #但是可以指定范圍查看
[2, 3]
>>> print(a[0:-1]) #指定范圍時，可以同時使用正數(shù)和負(fù)數(shù)進(jìn)行索引
[1, 2]
1
2
3
4
5
6
7
8
9
10
3.3.7.嵌套列表
#列表中也可以是列表，是可以無限嵌套的
>>> a = [[1,2,3],"aaa",[4,5,6]]
>>> print(a)
[[1, 2, 3], 'aaa', [4, 5, 6]]
>>> print(a[0]) #查看a列表中的第0個位置的元素
[1, 2, 3]
>>> print(a[0][0]) #查看a列表中第0個位置元素的第0個位置的元素
1
1
2
3
4
5
6
7
8
3.3.8.字符串轉(zhuǎn)列表
str1 = "12345"
list1 = list(str1)
print list1
str2 = "123 sjhid dhi"
list2 = str2.split() #or list2 = str2.split(" ") #以“空”為分割來切割字符串生成列表
print list2
str3 = "www.google.com"
list3 = str3.split(".") #以“.”為結(jié)果分割
print list3
1
2
3
4
5
6
7
8
9
10
11
結(jié)果如下：
['1', '2', '3', '4', '5']
['123', 'sjhid', 'dhi']
['www', 'google', 'com']
1
2
3
3.3.9.反轉(zhuǎn)列表元素
a=[1,2,3,4]
b=a[-1::-1] #第一個-1表示從4開始，::表示移動到列表末尾，也就是移動到1，第二個-1表示逆向
print(b)
輸出結(jié)果
[4, 3, 2, 1]
1
2
3
4
5
6
3.4.元組（Tuple）
元組類似于一個只讀列表，寫入元素后，元組中的元素是不可變的，操作速度比列表要快，安全性更強(qiáng)，使用（）來創(chuàng)建元組
雖然tuple的元素不可改變，但它可以包含可變的對象，比如list列表
構(gòu)造包含 0 個或 1 個元素的元組比較特殊，所以有一些額外的語法規(guī)則：
tup1 = () # 空元組
tup2 = (20,) # 一個元素，需要在元素后添加逗號
1
2
3.4.1元組的創(chuàng)建和刪除
a = (1,2,3)
print(a)
(1, 2, 3)
a[0] = 4 #元組的元素不能修改，會報錯
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
del a #在刪除元組時，只能全部刪除，不能指定刪除某個元素
print(a)
Traceback (most recent call last):
File "<input>", line 1, in <module>
print(a[1:6]) #但是可以指定范圍查看
[2, 3]
>>> print(a[0:-1]) #指定范圍時，可以同時使用正數(shù)和負(fù)數(shù)進(jìn)行索引
[1, 2]
1
2
3
4
5
6
7
8
9
10
3.3.7.嵌套列表
#列表中也可以是列表，是可以無限嵌套的
>>> a = [[1,2,3],"aaa",[4,5,6]]
>>> print(a)
[[1, 2, 3], 'aaa', [4, 5, 6]]
>>> print(a[0]) #查看a列表中的第0個位置的元素
[1, 2, 3]
>>> print(a[0][0]) #查看a列表中第0個位置元素的第0個位置的元素
1
1
2
3
4
5
6
7
8
3.3.8.字符串轉(zhuǎn)列表
str1 = "12345"
list1 = list(str1)
print list1
str2 = "123 sjhid dhi"
list2 = str2.split() #or list2 = str2.split(" ") #以“空”為分割來切割字符串生成列表
print list2
str3 = "www.google.com"
list3 = str3.split(".") #以“.”為結(jié)果分割
print list3
1
2
3
4
5
6
7
8
9
10
11
結(jié)果如下：
['1', '2', '3', '4', '5']
['123', 'sjhid', 'dhi']
['www', 'google', 'com']
1
2
3
3.3.9.反轉(zhuǎn)列表元素
a=[1,2,3,4]
b=a[-1::-1] #第一個-1表示從4開始，::表示移動到列表末尾，也就是移動到1，第二個-1表示逆向
print(b)
#輸出結(jié)果
[4, 3, 2, 1]
1
2
3
4
5
6
3.4.元組（Tuple）
元組類似于一個只讀列表，寫入元素后，元組中的元素是不可變的，操作速度比列表要快，安全性更強(qiáng)，使用（）來創(chuàng)建元組
雖然tuple的元素不可改變，但它可以包含可變的對象，比如list列表
構(gòu)造包含 0 個或 1 個元素的元組比較特殊，所以有一些額外的語法規(guī)則：
tup1 = () # 空元組
tup2 = (20,) # 一個元素，需要在元素后添加逗號
1
2
3.4.1元組的創(chuàng)建和刪除
>>> a = (1,2,3)
>>> print(a)
(1, 2, 3)
>>> a[0] = 4 #元組的元素不能修改，會報錯
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> del a #在刪除元組時，只能全部刪除，不能指定刪除某個元素
>>> print(a)
Traceback (most recent call last):
File "<input>", line 1, in <module>
NameError: name 'a' is not defined
1
2print(a[0:-1]) #指定范圍時，可以同時使用正數(shù)和負(fù)數(shù)進(jìn)行索引
[1, 2]
1
2
3
4
5
6
7
8
9
10
3.3.7.嵌套列表
#列表中也可以是列表，是可以無限嵌套的
>>> a = [[1,2,3],"aaa",[4,5,6]]
>>> print(a)
[[1, 2, 3], 'aaa', [4, 5, 6]]
>>> print(a[0]) #查看a列表中的第0個位置的元素
[1, 2, 3]
>>> print(a[0][0]) #查看a列表中第0個位置元素的第0個位置的元素
1
1
2
3
4
5
6
7
8
3.3.8.字符串轉(zhuǎn)列表
str1 = "12345"
list1 = list(str1)
print list1
str2 = "123 sjhid dhi"
list2 = str2.split() #or list2 = str2.split(" ") #以“空”為分割來切割字符串生成列表
print list2
str3 = "www.google.com"
list3 = str3.split(".") #以“.”為結(jié)果分割
print list3
1
2
3
4
5
6
7
8
9
10
11
結(jié)果如下：
['1', '2', '3', '4', '5']
['123', 'sjhid', 'dhi']
['www', 'google', 'com']
1
2
3
3.3.9.反轉(zhuǎn)列表元素
a=[1,2,3,4]
b=a[-1::-1] #第一個-1表示從4開始，::表示移動到列表末尾，也就是移動到1，第二個-1表示逆向
print(b)
#輸出結(jié)果
[4, 3, 2, 1]
1
2
3
4
5
6
3.4.元組（Tuple）
元組類似于一個只讀列表，寫入元素后，元組中的元素是不可變的，操作速度比列表要快，安全性更強(qiáng)，使用（）來創(chuàng)建元組
雖然tuple的元素不可改變，但它可以包含可變的對象，比如list列表
構(gòu)造包含 0 個或 1 個元素的元組比較特殊，所以有一些額外的語法規(guī)則：
tup1 = () # 空元組
tup2 = (20,) # 一個元素，需要在元素后添加逗號
1
2
3.4.1元組的創(chuàng)建和刪除
>>> a = (1,2,3)
>>> print(a)
(1, 2, 3)
>>> a[0] = 4 #元組的元素不能修改，會報錯
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> del a #在刪除元組時，只能全部刪除，不能指定刪除某個元素
>>> print(a)
Traceback (most recent call last):
File "<input>", line 1, in <module>
NameError: name 'a' is not defined
1
2
3
print(a[0:-1]) #指定范圍時，可以同時使用正數(shù)和負(fù)數(shù)進(jìn)行索引
[1, 2]
1
2
3
4
5
6
7
8
9
10
3.3.7.嵌套列表
#列表中也可以是列表，是可以無限嵌套的
>>> a = [[1,2,3],"aaa",[4,5,6]]
>>> print(a)
[[1, 2, 3], 'aaa', [4, 5, 6]]
>>> print(a[0]) #查看a列表中的第0個位置的元素
[1, 2, 3]
>>> print(a[0][0]) #查看a列表中第0個位置元素的第0個位置的元素
1
1
2
3
4
5
6
7
8
3.3.8.字符串轉(zhuǎn)列表
str1 = "12345"
list1 = list(str1)
print list1
str2 = "123 sjhid dhi"
list2 = str2.split() #or list2 = str2.split(" ") #以“空”為分割來切割字符串生成列表
print list2
str3 = "www.google.com"
list3 = str3.split(".") #以“.”為結(jié)果分割
print list3
1
2
3
4
5
6
7
8
9
10
11
結(jié)果如下：
['1', '2', '3', '4', '5']
['123', 'sjhid', 'dhi']
['www', 'google', 'com']
1
2
3
3.3.9.反轉(zhuǎn)列表元素
a=[1,2,3,4]
b=a[-1::-1] #第一個-1表示從4開始，::表示移動到列表末尾，也就是移動到1，第二個-1表示逆向
print(b)
#輸出結(jié)果
[4, 3, 2, 1]
1
2
3
4
5
6
3.4.元組（Tuple）
元組類似于一個只讀列表，寫入元素后，元組中的元素是不可變的，操作速度比列表要快，安全性更強(qiáng)，使用（）來創(chuàng)建元組
雖然tuple的元素不可改變，但它可以包含可變的對象，比如list列表
構(gòu)造包含 0 個或 1 個元素的元組比較特殊，所以有一些額外的語法規(guī)則：
tup1 = () # 空元組
tup2 = (20,) # 一個元素，需要在元素后添加逗號
1
2
3.4.1元組的創(chuàng)建和刪除
>>> a = (1,2,3)
>>> print(a)
(1, 2, 3)
>>> a[0] = 4 #元組的元素不能修改，會報錯
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> del a #在刪除元組時，只能全部刪除，不能指定刪除某個元素
>>> print(a)
Traceback (most recent call last):
File "<input>", line 1, in <module>
NameError: name 'a' is not defined
1
2
3
4
5
6
7
8
9
10
11
12
3.4.2.元組和列表的互相轉(zhuǎn)換
a = [1,2,3]
b = (1,2,3)
c = list(b) #轉(zhuǎn)換時，需要重新定義變量
print(c)
[1, 2, 3]
print(type(c)) #查看c變量的類型，發(fā)現(xiàn)是列表
<class 'list'>
d = tuple(a) #把a(bǔ)列表變成元組，并且重新定義變量成d
print(d)
(1, 2, 3)
print(type(d))
<class 'tuple'>
1
2
3
4
5
6
7
8
9
10
11
12
3.5.集合（Set）
集合是由一個或數(shù)個形態(tài)各異的大小整體組成的，構(gòu)成集合的事物或?qū)ο蠓Q作元素或是成員
基本功能是進(jìn)行成員關(guān)系測試和刪除重復(fù)元素
可以使用大括號{ }或者是set( )函數(shù)創(chuàng)建集合，要注意的是，創(chuàng)建一個空集合必須使用set( )，因為{ }使用來創(chuàng)建一個空字典的
創(chuàng)建格式：
a = {value1,value2,...}
set(value)
1
2
3.5.1.集合的創(chuàng)建
a = {'aaa','bbb','ccc','ddd'}
print(a)
print(type(a))
輸出結(jié)果：
{'aaa', 'ddd', 'bbb', 'ccc'}
<class 'set'>
1
2
3
4
5
6
7
b=set("aaaa5cccddd")
print(b)
print(type(b))
輸出結(jié)果：
{'a', 'd', 'c', '5'}
<class 'set'>
1
2
3
4
5
6
7
3.5.2.成員測試
a = {'aaa','bbb','ccc','ddd'}
if 'aaa' in a:
print("aaa在a集合中")
else:
print("aaa不在a集合中")
輸出結(jié)果：
aaa在a集合中
1
2
3
4
5
6
7
8
3.5.3.集合運(yùn)算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(b)
print(a - b) #a和b的差集
print(a | b) #a和b的并集
print(a & b) #a和b的交集
print(a ^ b) #a和b中不同時存在的元素
輸出結(jié)果：
{'b', 'r', 'd', 'c', 'a'}
{'l', 'z', 'm', 'c', 'a'}
{'r', 'd', 'b'}
{'l', 'z', 'b', 'r', 'd', 'm', 'c', 'a'}
{'a', 'c'}
{'l', 'r', 'z', 'b', 'd', 'm'}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
3.6.字典（Dictionary）
字典中的值，是通過鍵值對來存儲的，key-value的方式，使用{ }來創(chuàng)建字典，字典的索引由鍵和它對應(yīng)的值組成
列表是有序的對象集合，字典是無序的對象集合兩者之間的區(qū)別在于：字典當(dāng)中的元素是通過鍵來存取的，而不是通過偏移存取
字典是一種映射類型，字典用 { } 標(biāo)識，它是一個無序的 鍵(key) : 值(value) 的集合
鍵(key)必須使用不可變類型
在同一個字典中，鍵(key)必須是唯一的
3.6.1.字典的創(chuàng)建
字典中的鍵具有唯一性，但是值可以相同，鍵名區(qū)分大小寫，當(dāng)有多個相同的鍵名和值時，只有最后一個鍵值會生效
a = {"id":1,"name":"zhangsan"}
print(a)
{'id': 1, 'name': 'zhangsan'}
print(type(a))
<class 'dict'>
print(a["id"]) #索引a字典中，id鍵的值
1
print(a["name"])
zhangsan
a = {"id":1,"id":2,"id":3}
print(a) #字典中有多個相同的鍵時，只有最后一個鍵值會生效
{'id': 3}
del a #刪除a字典
1
2
3
4
5
6
7
8
9
10
11
12
13
14
3.6.2.字典中鍵的添加、修改、刪除操作
添加：
a={"aaa":1,"bbb":2}
a["ccc"] = 3 #添加不存在的鍵值即可
print(a)
輸出結(jié)果：
{'aaa': 1, 'bbb': 2, 'ccc': 3}
——————————————————————————————
修改：
a={"aaa":1,"bbb":2}
a["aaa"] = 3 #修改指定鍵的值
print(a)
輸出結(jié)果：
{'aaa': 3, 'bbb': 2}
——————————————————————————————
刪除：
a={"aaa":1,"bbb":2}
del a["aaa"] #刪除指定的鍵值
print(a)
輸出結(jié)果：
{'bbb': 2}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
3.7.Python數(shù)據(jù)類型轉(zhuǎn)換
有時候，我們需要對數(shù)據(jù)內(nèi)置的類型進(jìn)行轉(zhuǎn)換，數(shù)據(jù)類型的轉(zhuǎn)換，你只需要將數(shù)據(jù)類型作為函數(shù)名即可
以下幾個內(nèi)置的函數(shù)可以執(zhí)行數(shù)據(jù)類型之間的轉(zhuǎn)換這些函數(shù)返回一個新的對象，表示轉(zhuǎn)換的值
函數(shù) 描述\作用
int(x [,base]) 將x轉(zhuǎn)換為一個整數(shù)
float(x) 將x轉(zhuǎn)換到一個浮點數(shù)
complex(real [,imag]) 創(chuàng)建一個復(fù)數(shù)
str(x) 將對象 x 轉(zhuǎn)換為字符串
repr(x) 將對象 x 轉(zhuǎn)換為表達(dá)式字符串
eval(str) 用來計算在字符串中的有效Python表達(dá)式,并返回一個對象
tuple(s) 將序列 s 轉(zhuǎn)換為一個元組
list(s) 將序列 s 轉(zhuǎn)換為一個列表
set(s) 轉(zhuǎn)換為可變集合
dict(d) 創(chuàng)建一個字典d 必須是一個 (key, value)元組序列
frozenset(s) 轉(zhuǎn)換為不可變集合
chr(x) 將一個整數(shù)轉(zhuǎn)換為一個字符
ord(x) 將一個字符轉(zhuǎn)換為它的整數(shù)值
hex(x) 將一個整數(shù)轉(zhuǎn)換為一個十六進(jìn)制字符串
oct(x) 將一個整數(shù)轉(zhuǎn)換為一個八進(jìn)制字符串
4.Python3基礎(chǔ)語法
4.1.編碼
默認(rèn)情況下，Python 3 源碼文件以 UTF-8 編碼，所有字符串都是 unicode 字符串 當(dāng)然你也可以為源碼文件指定不同的編碼：
-- coding: cp-1252 --
1
上述定義允許在源文件中使用 Windows-1252 字符集中的字符編碼，對應(yīng)適合語言為保加利亞語、白羅斯語、馬其頓語、俄語、塞爾維亞語
一般來說都是直接指定utf-8
-- coding: utf-8 --
1
4.2.標(biāo)識符
第一個字符必須是字母表中字母或下劃線 _
標(biāo)識符的其他的部分由字母、數(shù)字和下劃線組成
標(biāo)識符對大小寫敏感
注意：在 Python 3 中，可以用中文作為變量名，非 ASCII 標(biāo)識符也是允許的了
4.3.Python保留字
保留字即關(guān)鍵字，我們不能把它們用作任何標(biāo)識符名稱Python 的標(biāo)準(zhǔn)庫提供了一個 keyword 模塊，可以輸出當(dāng)前版本的所有關(guān)鍵字：
import keyword
keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
1
2
3
4.3.注釋
Python中單行注釋以# 開頭，實例如下：
!/usr/bin/python3
第一個注釋
print ("Hello, Python!") # 第二個注釋
1
2
3
執(zhí)行以上代碼，輸出結(jié)果為：
Hello, Python!
1
多行注釋可以用多個 # 號，還有 ''' 和 """：
!/usr/bin/python3
第一個注釋
第二個注釋
'''
第三注釋
第四注釋
'''
"""
第五注釋
第六注釋
"""
print ("Hello, Python!")
1
2
3
4
5
6
7
8
9
10
11
12
執(zhí)行以上代碼，輸出結(jié)果為：
Hello, Python!
1
4.4.行與縮進(jìn)
python最具特色的就是使用縮進(jìn)來表示代碼塊，不需要使用大括號 {}
縮進(jìn)的空格數(shù)是可變的，但是同一個代碼塊的語句必須包含相同的縮進(jìn)空格數(shù)實例如下：
if True:
print ("True")
else:
print ("False")
1
2
3
4
以下代碼最后一行語句縮進(jìn)數(shù)的空格數(shù)不一致，會導(dǎo)致運(yùn)行錯誤：
if True:
print ("Answer")
print ("True")
else:
print ("Answer")
print ("False") # 縮進(jìn)不一致，會導(dǎo)致運(yùn)行錯誤
1
2
3
4
5
6
以上程序由于縮進(jìn)不一致，執(zhí)行后會出現(xiàn)類似以下錯誤：
File "test.py", line 6
print ("False") # 縮進(jìn)不一致，會導(dǎo)致運(yùn)行錯誤
^
IndentationError: unindent does not match any outer indentation level
1
2
3
4
4.5.多行語句
Python 通常是一行寫完一條語句，但如果語句很長，我們可以使用反斜杠 \來實現(xiàn)多行語句，例如：
total = item_one +
item_two +
item_three
1
2
3
在 [], {}, 或 () 中的多行語句，不需要使用反斜杠 ****，例如：
total = ['item_one', 'item_two', 'item_three',
'item_four', 'item_five']
1
2
4.6.空行
函數(shù)之間或類的方法之間用空行分隔，表示一段新的代碼的開始類和函數(shù)入口之間也用一行空行分隔，以突出函數(shù)入口的開始
空行與代碼縮進(jìn)不同，空行并不是Python語法的一部分書寫時不插入空行，Python解釋器運(yùn)行也不會出錯但是空行的作用在于分隔兩段不同功能或含義的代碼，便于日后代碼的維護(hù)或重構(gòu)
注意：空行也是程序代碼的一部分
4.7.等待用戶輸入
執(zhí)行下面的程序在按回車鍵后就會等待用戶輸入：
#!/usr/bin/python3
input("\n\n按下 enter 鍵后退出") #利用input交互式賦予變量值
1
2
以上代碼中 ，\n\n在結(jié)果輸出前會輸出兩個新的空行一旦用戶按下 enter 鍵時，程序?qū)⑼顺?/p>
4.8.同一行顯示多條語句
Python 可以在同一行中使用多條語句，語句之間使用分號 ; 分割，以下是一個簡單的實例：
#!/usr/bin/python3
import sys; x = 'runoob'; sys.stdout.write(x + '\n')
1
2
使用腳本執(zhí)行以上代碼，輸出結(jié)果為：
runoob
1
使用交互式命令行執(zhí)行，輸出結(jié)果為：
import sys; x = 'runoob'; sys.stdout.write(x + '\n')
runoob
7
1
2
3
此處的 7 表示字符數(shù)
4.9.多個語句構(gòu)成代碼組
縮進(jìn)相同的一組語句構(gòu)成一個代碼塊，我們稱之代碼組
像if、while、def和class這樣的復(fù)合語句，首行以關(guān)鍵字開始，以冒號( : )結(jié)束，該行之后的一行或多行代碼構(gòu)成代碼組
我們將首行及后面的代碼組稱為一個子句(clause)
如下實例：
if expression :
suite
elif expression :
suite
else :
suite
1
2
3
4
5
6
4.10.print輸出
print默認(rèn)輸出是換行的，如果要實現(xiàn)不換行需要在變量末尾加上 end=""：
#!/usr/bin/python3
x="a"
y="b"
換行輸出
print( x )
print( y )
print('---------')
不換行輸出
print( x, end=" " )
print( y, end=" " )
print()
1
2
3
4
5
6
7
8
9
10
11
以上實例執(zhí)行結(jié)果為：
a
b
a b
1
2
3
4
4.11.import和from…import
在 python 用 import 或者 from...import 來導(dǎo)入相應(yīng)的模塊
將整個模塊(somemodule)導(dǎo)入，格式為： import somemodule
從某個模塊中導(dǎo)入某個函數(shù),格式為： from somemodule import somefunction
從某個模塊中導(dǎo)入多個函數(shù),格式為： from somemodule import firstfunc, secondfunc, thirdfunc
將某個模塊中的全部函數(shù)導(dǎo)入，格式為： from somemodule import *
導(dǎo)入sys模塊
import sys
print('================Python import mode==========================')
print ('命令行參數(shù)為:')
for i in sys.argv:
print (i)
print ('\n python 路徑為',sys.path)
導(dǎo)入sys模塊的argv,path成員
from sys import argv,path # 導(dǎo)入特定的成員
print('================python from import===================================') print('path:',path) # 因為已經(jīng)導(dǎo)入path成員，所以此處引用時不需要加sys.path
1
2
3
4
5
6
7
8
9
10
11
4.12.命令行參數(shù)
很多程序可以執(zhí)行一些操作來查看一些基本信息，Python可以使用-h參數(shù)查看各參數(shù)幫助信息：
$ python -h
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-c cmd : program passed in as string (terminates option list)
-d : debug output from parser (also PYTHONDEBUG=x)
-E : ignore environment variables (such as PYTHONPATH)
-h : print this help message and exit
[ etc. ]
1
2
3
4
5
6
7
8
9
我們在使用腳本形式執(zhí)行 Python 時，可以接收命令行輸入的參數(shù)
二、拓展小腳本
-選車牌小程序
import random
import string #導(dǎo)入變量
car_num = string.digits+string.ascii_uppercase #定義一個變量，這個變量的值是隨機(jī)的數(shù)字和大寫字母組成的字符串
print("請選擇你的車牌號") #提示語
a = 3 #預(yù)定義變量用作于while循環(huán)
while a > 0: #當(dāng)a變量的值大于0時進(jìn)行循環(huán)，a變量定義為3
num_list = [] #定義一個空列表
for i in range(20): #定義for循環(huán)，循環(huán)20次
choice = random.choice(string.ascii_uppercase) #定義變量，這個變量的值是隨機(jī)的一位大寫字母
car = f"京{choice}-{''.join(random.sample(car_num,5))}" #定義變量，這個變量就是車牌號，利用join把上面變量的五位字符串整合到一起
car = str(car) #上面的變量定義為字符串類型
num_list.append(car) #把新建變量加入上面定義的空列表，加入到末尾
print(f"這是第{i}次的車牌號：{car}") #提示語
aaa = input("請選擇你的車牌:") #利用交互式函數(shù)input對aaa變量進(jìn)行賦值
if aaa in num_list: #對aaa變量進(jìn)行判斷輸入的變量值是否在上面的列表中
print(f"恭喜你選中車牌，車牌號是:{aaa}") #有的話輸出提示語并且退出循環(huán)
break
else:
a -= 1 #沒有的話利用while循環(huán)a的值進(jìn)行提示
print(f"對不起，你沒有選中車牌，你還有{a}次機(jī)會")
if a == 0:
print("對不起，你已經(jīng)無法選擇車牌了")
else:
print("請重新選擇")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
-99乘法表
for a in range(1,9):
for b in range(1,9):
if b <= a:
c = a * b
print(f"{a} * = {c}\t", end="")
print("")
1
2
3
4
5
6
- 年會抽獎小程序
import random
import string
list_1 = []
for i in range(1,300):
name_1 = string.ascii_uppercase
name_2 = random.sample(name_1,2)
name_3 = str(i) + ''.join(name_2)
list_1.append(name_3)
print(list_1)
print(random.choice(list_1))
a = 1
b = 1
c = 1
while a < 4:
while b < 7:
while c < 31:
san = random.choice(list_1)
print(f"抽三等獎，獎品是byt,第{c}位抽獎的是{san},恭喜獲得三等獎")
list_1.remove(san)
c = c + 1
er = random.choice(list_1)
print(f"抽二等獎，獎品是iphone,第位抽獎的是{er},恭喜獲得二等獎")
list_1.remove(er)
b = b + 1
yi = random.choice(list_1)
print(f"抽一等獎，獎品是泰國五日游,第{a}位抽獎的是{yi},恭喜獲得一等獎")
list_1.remove(yi)
a = a + 1
print(list_1)
————————————————
版權(quán)聲明：本文為CSDN博主「礁之」的原創(chuàng)文章，遵循CC 4.0 BY-SA版權(quán)協(xié)議，轉(zhuǎn)載請附上原文出處鏈接及本聲明。
原文鏈接：https://blog.csdn.net/rzy1248873545/article/details/124535728
