Python中基本數據類型和常用語法有哪些

這篇“Python中基本數據類型和常用語法有哪些”文章的知識點大部分人都不太理解，所以小編給大家總結了以下內容，內容詳細，步驟清晰，具有一定的借鑒價值，希望大家閱讀完這篇文章能有所收獲，下面我們一起來看看這篇“Python中基本數據類型和常用語法有哪些”文章吧。

整數

在Python中，整數（integer）是一種內置數據類型，用于表示整數值。Python中的整數類型可以表示任意大小的整數，而不需要考慮計算機字長的限制。這是因為Python會自動根據需要調整整數類型的位數，以便可以存儲任意大小的整數。

以下是一些整數的示例：

x = 42          # 整數常量
y = -123        # 負整數常量
z = 0           # 零
#除法操作返回的結果可以是整數或浮點數，具體取決于操作數的類型和結果。如果除法的操作數都是整數，則結果為整數，如果有一個操作數是浮點數，則結果為浮點數。
x = 10
y = 3
print(x + y)      # 輸出結果為13
print(x / y)      # 輸出結果為3.3333333333333335
#在上面的示例中，我們定義了兩個整數x和y，然后對它們進行了加法和除法操作，并打印了結果。注意，除法操作返回的結果是一個浮點數，而不是整數。如果要將結果轉換為整數，可以使用`int()`函數進行轉換。例如：
x = 10
y = 3
result = int(x / y)
print(result)      # 輸出結果為3

在Python中，對于大數字的表示，可以直接使用整型或者長整型（long integer），不需要使用科學計數法。

在Python 2.x 中，整型的大小是有限制的，最大值是 2^31 - 1，如果需要表示更大的整數，可以使用長整型。長整型在表示時不受大小限制，因為它們可以自動調整大小以適應所需的精度。可以使用 "L" 后綴將一個整數字面量標記為長整型，例如：12345678901234567890L。

在Python 3.x 中，整型已經沒有大小限制，可以直接表示非常大的整數，而且不需要使用長整型。在Python 3.x 中，長整型已經被整合到普通的整型中，因此在表示大數字時，不需要任何額外的標記或語法。

例如，在Python中可以這樣表示一個非常大的整數：

x = 123456789012345678901234567890

空值

當談到Python中的空值時，我們可以將其看作是一個占位符，用于表示沒有值或空值。

在Python中，空值由一個內置對象 None 表示,這個對象是特殊的，可以用作任何類型的占位符。當變量未賦值或函數返回值需要一個占位符時，我們通常使用None來表示空值。以下是一個簡單的示例，展示了如何使用None：

x = None      # 將變量x設置為None
y = 10        # 將變量y設置為一個整數值
z = None      # 將變量z設置為None

if x is None:
    print("x is None")
else:
    print("x is not None")

在上面的示例中，我們首先將變量x和z設置為None。然后，我們使用is運算符檢查變量x是否為None。由于x確實是None，所以條件if x is None成立，打印出"x is None"。相反，如果變量x包含任何其他值（例如整數值），則該條件將不成立。

需要注意的是，None不同于空字符串或空列表。空字符串表示沒有字符，而空列表表示沒有元素。相比之下，None是一個對象，它表示沒有值或空值。因此，在編寫Python代碼時，應該正確理解和使用None，以避免混淆和錯誤。

浮點數

在Python中，浮點數是一種內置數據類型，用于表示實數。與整數類型不同的是，浮點數是近似值，而不是精確值。這是因為Python采用了雙精度浮點數格式來表示浮點數，這種格式可以表示非常大和非常小的數字，但是由于近似性和舍入誤差，會導致一些精度問題。因此，當使用浮點數時，需要注意舍入誤差和精度問題。

在Python中，可以使用小數點來表示浮點數，也可以使用科學計數法。例如，下面是一些浮點數的示例：

x = 3.14159      # 浮點數常量
y = -0.0001      # 負浮點數常量
z = 2.0e-6       # 科學計數法表示的浮點數（0.000002）
#Python中的浮點數可以執行各種算術操作，如加法、減法、乘法和除法等。下面是一個簡單的示例，計算三個浮點數之和：
x = 0.1
y = 0.2
z = 0.3
print(x + y + z)   # 輸出結果為0.6000000000000001
#Python中的浮點數可以執行各種算術操作，如加法、減法、乘法和除法等。下面是一個簡單的示例，計算三個浮點數之和：
x = 0.1
y = 0.2
z = 0.3
print(x + y + z)   # 輸出結果為0.6000000000000001
#在上面的示例中，我們計算三個浮點數之和，并打印結果。然而，輸出結果并不是期望的0.6，而是一個近似值0.6000000000000001。這是由于浮點數的近似性和舍入誤差導致的。為了避免這種問題，我們可以使用`round()`函數對浮點數進行四舍五入，以便得到更精確的結果。例如：
x = 0.1
y = 0.2
z = 0.3
result = round(x + y + z, 2)   # 對浮點數進行四舍五入，并保留兩位小數
print(result)   # 輸出結果為0.6

在上面的示例中，我們使用round()函數對浮點數進行四舍五入，并保留兩位小數。然后，我們打印結果，得到期望的0.6。

與、或、非，運算符

Python中的邏輯運算符有三種：與運算（and）、或運算（or）和非運算（not）。這些邏輯運算符可以用于布爾類型的值（True或False），也可以用于其他類型的值。

用法如下：

#1.  與運算
#與運算（`and`）用于判斷兩個條件是否都為True。如果兩個條件都為True，則返回True，否則返回False。以下是與運算的一些示例：
x = 5
y = 10
result = x < 10 and y > 5
print(result)      # 輸出結果為True
#在上面的示例中，我們使用與運算符`and`判斷兩個條件是否都為True，并打印了結果
#2.  或運算
#或運算（`or`）用于判斷兩個條件中是否有至少一個為True。如果兩個條件都為False，則返回False，否則返回True。以下是或運算的一些示例：
x = 5
y = 10
result = x < 10 or y < 5
print(result)      # 輸出結果為True
#在上面的示例中，我們使用或運算符`or`判斷兩個條件中是否有至少一個為True，并打印了結果。
#3.  非運算
#非運算（`not`）用于對一個條件進行取反操作，如果條件為True，則返回False，如果條件為False，則返回True。以下是非運算的一些示例：
x = 5
result = not x > 10
print(result)      # 輸出結果為True
#在上面的示例中，我們使用非運算符`not`對一個條件進行取反操作，并打印了結果。
#總之，在Python中，邏輯運算符可以用于布爾類型的值（True或False），也可以用于其他類型的值。這些邏輯運算符包括與運算（`and`）、或運算（`or`）和非運算（`not`），可以用于各種邏輯操作中。

字符編碼

因為計算機是老外發明的，最初只能識別大小寫英文字母、數字和一些符號，這些是通過 ASCII 編碼實現的，如下圖所示 B的編碼是 66，1的 編碼是 49；

隨著計算機和互聯網的發展，全球各個國家都要使用，ASCII 編碼顯然不足以表示中文等其他字符，這個過程中中國制定了 GB2312, 韓國制定了 Euc-kr 等自己的編碼格式，為了防止沖突，后來誕生了 Unicode 字符集，它把所有的編碼都統一起來，解決了編碼沖突導致的亂碼問題，后來又衍生出了更節約成本的 “可變長編碼” UTF-8 編碼。

我們梳理下 ASCII, Unicode, UTF-8 的區別：

ASCII、Unicode和 UTF-8 都是字符編碼的標準，用于將字符轉換為二進制數字以便計算機處理。它們之間的主要區別在于編碼的方式和能夠表示的字符集。

ASCII是一種最早的字符編碼標準，它定義了 128 個字符，包括英文字母、數字和一些標點符號等基本符號。ASCII采用7位二進制編碼表示字符，可以表示的字符范圍是 0-127。

Unicode是一種用于表示字符集的標準，它定義了世界上幾乎所有的字符集，包括中文、日文、韓文等各種語言的字符。Unicode使用32位二進制編碼表示字符，可以表示的字符范圍非常廣泛，包括標點符號、表情符號、數學符號等等。

UTF-8 是 Unicode 的一種編碼方式，它是一種可變長度編碼方式，能夠表示Unicode中的任何字符，包括中文、日文、韓文等各種語言的字符。UTF-8對于英文字母、數字和常用符號等ASCII字符只需1個字節編碼，比較節省空間。在UTF-8編碼中，使用1個字節表示0-127范圍內的字符，2個字節表示 128-2047 范圍內的字符，3個字節表示 2048-65535 范圍內的字符，4個字節表示 65536-1114111 范圍內的字符。

總的來說，ASCII是最基本的字符編碼方式，Unicode擴展了字符集的范圍，而UTF-8則是Unicode的一種編碼方式，具有可變長度編碼和兼容ASCII編碼的優點，因此被廣泛應用于互聯網和計算機系統中。

字符串

了解了字符編碼，我們再來看字符串，Python中，字符串是一個不可變的序列（Sequence），用于表示一段字符序列, 采用 Unicode 編碼方式，因此可以表示世界上幾乎所有的字符。

#Python中的字符串可以用單引號、雙引號或三引號來表示
str1 = 'Hello, world!'  # 使用單引號
str2 = "Hello, world!"  # 使用雙引號
str3 = '''Hello, 
          world!'''     # 使用三引號表示多行字符串
#字符串是不可變的，也就是說，一旦定義了一個字符串，就不能再修改它的值，只能重新定義一個新的字符串。
str1 = 'Hello, world!'
str1[0] = 'h'  # 錯誤，字符串不可變
##Python中的字符串支持各種常見的操作，例如字符串連接、字符串切片、字符串查找、大小寫轉換等等。例如：
str1 = 'Hello, '
str2 = 'world!'
str3 = str1 + str2  # 字符串連接
print(str3)  # 輸出：Hello, world!
str4 = 'hello, world!'
print(str4[0:5])  # 輸出：hello，字符串切片
print(str4.find('world'))  # 輸出：7，查找字符串中子串的位置
print(str4.upper())  # 輸出：HELLO, WORLD!，將字符串轉換為大寫
#Python中的字符串非常靈活，可以通過各種操作來實現字符串的處理和轉換。同時，Python也提供了豐富的字符串處理庫，例如正則表達式庫re，可以更加高效和方便地處理字符串。

列表（list）, 元祖（tuple）

python 中提供了 list 和 tuple 來表示有序集合，其區別是 list 可修改，tuple （元祖）一旦初始化就不能修改；

詳細介紹如下：

list

在Python中，數組通常用列表（list）來表示。列表是一種有序的可變序列，它可以存儲任意類型的元素。列表的索引從0開始，可以通過索引訪問和修改元素。以下是一個示例：

#1. 創建列表
#可以使用方括號 [] 或 list() 函數創建一個新的列表
my_list = [1, 2, 3, "hello"]
another_list = list(range(5))
#2. 訪問列表元素
#可以使用索引來訪問列表中的元素，索引從0開始。也可以使用負數索引從列表末尾開始倒數訪問元素
print(my_list[0])  # 輸出 1
print(my_list[-1])  # 輸出 "hello"
#3. 切片操作
##可以使用切片操作訪問列表的子序列，切片操作的語法為 start:end:step
print(my_list[1:3])  # 輸出 [2, 3]
print(my_list[:2])  # 輸出 [1, 2]
print(my_list[::2])  # 輸出 [1, 3]
#4. 修改列表
#可以使用索引來修改列表中的元素，也可以使用切片操作修改多個元素
my_list[0] = "new value"
my_list[1:3] = [4, 5]
'''5. 列表方法
Python列表提供了許多有用的方法來操作列表，例如：
- `append()` 在列表末尾添加一個元素
- `extend()` 將一個列表的元素添加到另一個列表的末尾
- `insert()` 在指定索引處插入一個元素
- `remove()` 刪除列表中第一個匹配的元素
- `pop()` 刪除并返回指定索引處的元素
- `index()` 返回指定元素在列表中第一次出現的索引
- `count()` 返回指定元素在列表中出現的次數
- `sort()` 對列表進行排序
- `reverse()` 將列表反轉
'''
my_list.append("new element")
my_list.extend([6, 7])
my_list.insert(1, "new element at index 1")
my_list.remove("hello")
popped_element = my_list.pop(2)
index_of_element = my_list.index("new element")
count_of_element = my_list.count(2)
my_list.sort()
my_list.reverse()
#6. 復制列表
##可以使用切片操作或者 `copy()` 方法來復制一個列表
my_list_copy = my_list[:]
my_list_copy = my_list.copy()
#7.獲取列表長度
#可以使用 `len()` 函數獲取一個列表的長度，即其中元素的個數
print(len(my_list))  # 輸出 4

tuple

在Python中，元組（tuple）是一個不可變（immutable）的序列，類似于列表（list），不同之處在于元組的元素不能被修改，添加或刪除。元組可以包含任何類型的對象，包括其他元組。

可以使用圓括號 () 或者 tuple() 函數來創建一個元組。

#1. 創建：
my_tuple = (1, 2, 3, "hello")
another_tuple = tuple(range(5))
#2. 訪問元組元素
#可以使用索引來訪問元組中的元素，索引從0開始。也可以使用負數索引從元組末尾開始倒數訪問元素。
print(my_tuple[0])  # 輸出 1
print(my_tuple[-1])  # 輸出 "hello"
#3. 切片操作
#可以使用切片操作訪問元組的子序列，切片操作的語法為 start:end:step。
print(my_tuple[1:3])  # 輸出 (2, 3)
print(my_tuple[:2])  # 輸出 (1, 2)
print(my_tuple[::2])  # 輸出 (1, 3)
#4. 復制元組
#由于元組是不可變的，所以不能像列表那樣使用切片操作來復制一個元組。可以使用 `tuple()` 函數或者直接將一個元組賦值給另一個變量來復制一個元組，例如：
my_tuple_copy = tuple(my_tuple)
another_tuple = my_tuple
#5. 元組解包
#元組可以使用比較運算符進行比較，比較的規則是從左到右依次比較元組中的每一個元素，直到發現不相等的元素或者所有元素都比較完畢
(1, 2) < (1, 3)  # 返回 True
(1, 2) == (2, 1)  # 返回 False

條件判斷

可以使用條件判斷語句來根據某個條件來執行不同的代碼，Python中的條件判斷語句使用 if， elif， else 關鍵字

score = float(input("請輸入分數："))
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "E"
print("你的等級是：", grade)

除了 if 語句，Python還提供了一些其他的條件語句和表達式，如 while 循環和 for 循環，以及 and、or、not 等邏輯運算符。這些都是Python編程中非常基礎的知識點，需要學習掌握。

循環

python 有兩種基本的循環方式， for in 和 while, 基本用法如下

#1. for in 循環示例：
my_list = [1, 2, 3, 4, 5]
for num in my_list:
    print(num)
#2. while 循環示例
n = int(input("請輸入一個整數："))
factorial = 1
while n > 0:
    factorial *= n
    n -= 1
print(factorial)

除了 for 和 while 循環之外，Python 還提供了一些高級的循環控制語句，如 break、continue、else 等，這些語句能夠使循環更加靈活。

for 循環怎么獲取下標？

可以使用 enumerate() 函數來在 for 循環中同時獲取元素和它的索引。enumerate() 函數返回一個枚舉對象，其中每個元素都是一個元組，包含兩個元素：索引和對應的元素值。

my_list = ["apple", "banana", "orange"]

for i, fruit in enumerate(my_list):
    print(i, fruit)

# 0 apple
# 1 banana
# 2 orange

字典 (dict)

Python 中的字典（dict）是一種無序、可變的數據類型，相當于其他語言中的 map, 用于存儲鍵值對。

下面是一個簡單的字典示例：

my_dict = {'apple': 3, 'banana': 2, 'orange': 4}
'''字典有許多常用的操作，包括：
1.  訪問元素：可以通過鍵來訪問字典中的值，例如 `my_dict['apple']` 將返回 3。
2.  修改元素：可以通過鍵來修改字典中的值，例如 `my_dict['banana'] = 5` 將把 `banana` 的值修改為 5。
3.  添加元素：可以使用賦值語句來添加新的鍵值對，例如 `my_dict['grape'] = 6` 將添加一個新的鍵值對 `grape: 6`。
4.  刪除元素：可以使用 `del` 語句來刪除鍵值對，例如 `del my_dict['orange']` 將刪除鍵為 `orange` 的鍵值對。
5.  遍歷元素：可以使用 `for` 循環來遍歷字典中的鍵值對，例如：'''
   for key, value in my_dict.items():
    print(key, value)
#6. 獲取鍵、值、鍵值對的列表：可以使用 `keys()`、`values()` 和 `items()` 方法來分別獲取所有鍵、所有值和所有鍵值對的列表。例如:
  keys = my_dict.keys()
	values = my_dict.values()
	items = my_dict.items()
#注意，`keys()`、`values()` 和 `items()` 方法返回的是視圖對象，而不是列表。如果需要將其轉換為列表，可以使用 `list()` 函數來轉換。

集合（set）

集合（set）是一種無序、可變的數據類型，用于存儲一組唯一的對象，集合不允許重復元素，而且是無序的，即不支持通過索引來訪問元素，集合可以用花括號 {} 或 set() 函數來創建。

#1.創建集合：
my_set = {1, 2, 3}
my_set = set([1, 2, 3])
#2.添加元素
my_set.add(4)
my_set.update([4, 5, 6])
#3.刪除元素
my_set.remove(4)
my_set.discard(5)
my_set.pop()
#4.清空集合
my_set.clear()
#5.判斷元素是否在集合中
if 1 in my_set:
    print('1 is in the set')
#6.求交集、并集、差集
set1 = {1, 2, 3}
set2 = {2, 3, 4}
intersection = set1 & set2 # 求交集
union = set1 | set2 # 求并集
difference = set1 - set2 # 求差集
#7.遍歷集合
for item in my_set:
    print(item)

以上就是關于“Python中基本數據類型和常用語法有哪些”這篇文章的內容，相信大家都有了一定的了解，希望小編分享的內容對大家有幫助，若想了解更多相關的知識內容，請關注億速云行業資訊頻道。