一、基本輸入輸出

# input():將所有輸入都當作字串,需要型別轉換

num_int = int(input('Please input an int'))
num_float = float(input('Please input a float'))
num_complex = complex(input('Please input a complex'))
container_list = eval(input('Please input a list'))
container_tuple = eval(input('Please input a tuple'))
container_dic = eval(input('Please input a dic'))
container_set = eval(input('Please input a set'))

print(num_int)
print(num_float)
print(num_complex)
print(container_list)
print(container_tuple)
print(container_dic)
print(container_set)

# print()

num_int = 233
num_float = 2.6985
num_complex = 2+6j

print(num_int, num_float)                           # 默認空格分隔,回車結尾
print(num_int, num_float, num_complex, sep=',')     # 逗號分隔
print(num_int, num_float, num_complex, end='end')   # end結尾
print(num_int, num_float)

二、數學函式

import math
# 實數比大小
print(math.isclose(0.4-0.3, 0.1))

# 階乘
print(math.factorial(32))  # 32的階乘

# 平方根
print(7**0.5)  # 7的平方根

# 復數運算
c = 3+4j
print(c+c)             # 加
print(c**2)            # 冪運算
print(c.real)          # 查看實部
print(c.imag)          # 查看虛部
print(c.conjugate())   # 查看共軛復數
print(abs(c))          # 計算模

三、容器操作

# 容器定義
x_list = [1, 2, 3]                     # 串列
x_tuple = (1, 2, 3)                    # 元組
x_dict = {'a': 97, 'b': 98, 'c': 99}   # 字典
x_set = {1, 2, 3}                      # 集合

# 容器訪問
print(x_list[0], x_list[-1])           # 串列
print(x_tuple[0], x_tuple[-2])         # 元組
print(x_dict['a'])                     # 字典(不安全)
print(x_dict.get('speed'))             # 字典(安全),回傳None
print(x_set)                           # 集合,是無序的，不能索引

# 元素個數
print(len(x_list))
print(len(x_tuple))
print(len(x_dict))
print(len(x_set))

# 增加元素
x_list = []
x_tuple = ()
x_dic = {}
x_set = set()

x_list.append('list0')                       # 串列,增加在末尾
x_list.insert(0, 'listx')                    # 串列,增加在任意位置

x_tuple = (200, 50)                          # 元組,定義了就不能修改,除非重新定義

x_dic['key'] = 'value'                       # 字典,添加和修改一樣

x_set.add('set0')                            # 集合,無序,無需索引
x_set.update({1, 3})
x_set.update([1, 4], [5, 6])

print("After add:")
print("x_list:", x_list)
print("x_tuple:", x_tuple)
print("x_dic:", x_dic)
print("x_set:", x_set)

# 洗掉元素
x_list = ['list0', 'list1', 'list2', 'list3']
x_tuple = ('tuple0', 'tuple1', 'tuple2', 'tuple3')
x_dic = {'dic0': 0, 'dic1': 1, 'dic2': 2, 'dic3': 3, 'key': 'value'}
x_set = {'set0', 'set1', 'set2', 'set3', 'set4'}

del x_list[0]                                # 串列,洗掉0號位置
x_list.remove('list3')                       # 串列,洗掉值為list3的元素
popped_element = x_list.pop(1)               # 串列,彈出1號位置的元素,并賦給變數

# 元組,不可修改

del x_dic['key']                             # 字典,洗掉名稱為key的鍵值對

x_set.remove('set2')                         # 集合(不安全),洗掉名為set2的元素
x_set.discard('set2')                        # 集合(安全),不存在不會發生錯誤
x_set.pop()                                  # 集合(隨機洗掉一個元素)

print("\nAfter delete:")
print("x_list:", x_list)
print("x_tuple:", x_tuple)
print("x_dic:", x_dic)
print("x_set:", x_set)

# 清空or洗掉容器
x_list.clear()                              # 清空串列
del x_list                                  # 洗掉串列

# 元組不可修改
del x_tuple                                 # 洗掉元組

x_dic.clear()                               # 清空字典
del x_dic                                   # 洗掉字典

x_set.clear()                               # 清空集合
del x_set                                   # 洗掉集合

四、型別轉換

# int()

# 實數->整數
print(int(3.5))                 # 獲取實數的整數部分

# 字串->整數
print(int('119'))               # 把整數字串轉換為整數
print(int('  9\n'))             # 自動忽略字串兩個的空白字符

# 進制轉換
print(int('1111', 2))           # 把1111看作二進制數，轉換為十進制數
print(int('1111', 8))           # 把1111看作八進制數，轉換為十進制數
print(int('1111', 16))          # 把1111看作十六進制數，轉換為十進制數

#float()、complex()

# 字串->浮點數
print(float('3.1415926'))       # 把字串轉換為實數
print(float('-inf'))            # 負無窮大

# 產生復數
print(complex(3, 4))            # 復數
print(complex(6j))
print(complex('3'))

# bin()、oct()、hex()

# 進制轉換
print(bin(8888))              # 把整數轉換為二進制
print(oct(8888))              # 把整數轉換為八進制
print(hex(8888))              # 把整數轉換為十六進制

# ord()、chr()、str()

# ASCII or Unicode 字碼轉換
print(ord('a'))               # 回傳字符的ASCII碼
print(chr(65))                # 回傳指定ASCII碼對應的字符
print(ord('董'))              # 回傳漢字字符的Unicode編碼
print(chr(33891))             # 回傳指定Unicode編碼對應的漢字

# 容器->字串
print(str([1, 2, 3, 4]))      # 把串列轉換為字串
print(str({1, 2, 3, 4}))      # 把集合轉換為字串

# list()、tuple()、dict()、set()

# 集合->串列or元組
s = {3, 2, 1, 4}
print(list(s))
print(tuple(s))

# 串列->元組or集合
lst = [1, 1, 2, 2, 3, 4]
print(tuple(lst))
print(set(lst))  # 自動去重

# 字串->串列
print(str(lst))  # 包括[],逐字符插入
print(list(str(lst)))
print(tuple(str(lst)))
print(set(str(lst)))

# 鍵值對->字典
print(dict(name='Dong', sex='Male', age=41))

五、字串操作

【Python】字串，數，運算子_fftx_00的博客-CSDN博客

六、max(),min()

data = [3, 22, 111]
print(data)
# 串列,比較大小,最大or小元素
print(max(data))
print(min(data))

# 串列,轉換為字串后,表中最大單個字符
data = [3, 22, 111]
print(max(data, key=str))
# 串列,轉換為字串全小寫后,表中最大單個字符
data = ['abc', 'Abcd', 'ab']
print(max(data, key=str.lower))

# 字串串列,表中最長字串
data = ['3', '22', '111']
print(max(data, key=len))
# 字串串列,表中最大字串
data = ['abc', 'Abcd', 'ab']
print(max(data))

# 串列,表中出現次數最多的元素
data = [1, 1, 1, 2, 2, 1, 3, 1]
print(max(set(data), key=data.count))  # 也可以使用標準庫collections中的Counter類實作
# 串列,表中最大元素的位置，串列方法__getitem__()用于獲取指定位置的值
print(max(range(len(data)), key=data.__getitem__))

七、len(),sum()

# len():容器中元素的個數
# sum():容器中所有元素之和
data = [1, 2, 3, 4]
print(len(data))
print(sum(data))
data = (1, 2, 3)
print(len(data))
print(sum(data))
data = {1, 2, 3}
print(len(data))
print(sum(data))
data = 'Readability counts.'
print(len(data))                     # 字串長度
data = {1: 'a', 2: 'b', 3: 'c'}
print(len(data))                     # 鍵個數
print(sum(data))                     # 所有鍵相加

八、sorted(),reversed()

# sorted():  臨時升序排序

from random import shuffle
data = list(range(20))
shuffle(data)                  # 隨機打亂順序
print(data)
print(sorted(data))            # 升序排序

print(sorted(data, key=str))                 # 按轉換成字串后的大小升序排序
print(sorted(data, key=str, reverse=True))    # 按轉換成字串后的大小降序排序

# reversed():臨時逆轉容器順序
# 惰性求值,生成逆轉物件只能使用一次,
# 不支持使用內置函式len()計算元素個數,不支持使用內置函式reversed()再次翻轉

from random import shuffle
data = list(range(20))         # 創建串列
shuffle(data)                  # 隨機打亂順序
print(data)

reversedData = reversed(data)  # 生成reversed物件
print(list(reversedData))      # 根據reversed物件得到串列
print(tuple(reversedData))     # 空元組，reversed物件中元素只能使用一次

九、range()

# range(start, stop, step)生成數值串列

range1 = range(4)           # 只指定stop為4，start默認為0，step默認為1
range2 = range(5, 8)        # 指定start=5和stop=8，step默認為1
range3 = range(3, 20, 4)    # 指定start=3、stop=20和step=4
range4 = range(20, 0, -3)   # step也可以是負數

十、zip()

zip() 函式用于將可迭代的物件作為引數，將物件中對應位置的元素打包成一個個元組，然后回傳由這些元組組成的物件，這樣做的好處是節約了不少的記憶體，

我們可以使用 list() 轉換來輸出串列，

如果各個迭代器的元素個數不一致，則回傳串列長度與最短的物件相同，利用 * 號運算子，可以將元組解壓為串列，

十一、map()

map() 會根據提供的函式對指定序列做映射，

第一個引數 function 以引數序列中的每一個元素呼叫 function 函式，回傳包含每次 function 函式回傳值的新串列，

十二、reduce()

reduce() 函式會對引數序列中元素進行累積，

函式將一個資料集合（鏈表，元組等）中的所有資料進行下列操作：用傳給 reduce 中的函式 function（有兩個引數）先對集合中的第 1、2 個元素進行操作，得到的結果再與第三個資料用 function 函式運算，最后得到一個結果，

十三、filter()

filter() 函式用于過濾序列，過濾掉不符合條件的元素，回傳一個迭代器物件，如果要轉換為串列，可以使用 list() 來轉換，

該接收兩個引數，第一個為函式，第二個為序列，序列的每個元素作為引數傳遞給函式進行判斷，然后回傳 True 或 False，最后將回傳 True 的元素放到新串列中，