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

x = 123456789012345678901234567890

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

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

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

#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`），可以用于各種邏輯操作中。

#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中的字符串非常靈活，可以通過各種操作來實現(xiàn)字符串的處理和轉換。同時，Python也提供了豐富的字符串處理庫，例如正則表達式庫re，可以更加高效和方便地處理字符串。

#1. 創(chuàng)建列表
#可以使用方括號 [] 或 list() 函數(shù)創(chuàng)建一個新的列表
my_list = [1, 2, 3, "hello"]
another_list = list(range(5))
#2. 訪問列表元素
#可以使用索引來訪問列表中的元素，索引從0開始。也可以使用負數(shù)索引從列表末尾開始倒數(shù)訪問元素
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()` 返回指定元素在列表中第一次出現(xiàn)的索引
- `count()` 返回指定元素在列表中出現(xiàn)的次數(shù)
- `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()` 函數(shù)獲取一個列表的長度，即其中元素的個數(shù)
print(len(my_list))  # 輸出 4

#1. 創(chuàng)建：
my_tuple = (1, 2, 3, "hello")
another_tuple = tuple(range(5))
#2. 訪問元組元素
#可以使用索引來訪問元組中的元素，索引從0開始。也可以使用負數(shù)索引從元組末尾開始倒數(shù)訪問元素。
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()` 函數(shù)或者直接將一個元組賦值給另一個變量來復制一個元組，例如：
my_tuple_copy = tuple(my_tuple)
another_tuple = my_tuple
#5. 元組解包
#元組可以使用比較運算符進行比較，比較的規(guī)則是從左到右依次比較元組中的每一個元素，直到發(fā)現(xiàn)不相等的元素或者所有元素都比較完畢
(1, 2) < (1, 3)  # 返回 True
(1, 2) == (2, 1)  # 返回 False

score = float(input("請輸入分數(shù)："))
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)

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

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

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

# 0 apple
# 1 banana
# 2 orange

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` 循環(huán)來遍歷字典中的鍵值對，例如：'''
   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()` 函數(shù)來轉換。

#1.創(chuàng)建集合：
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)