'''
題目：
字符串為 "hahaha_lalala_xixixi",如何得到隊列 ["hahaha","lalala","xixixi"]
split()就是將一個字符串分裂成多個字符串，並以列表的形式返回
語法：str.split(str="", num=string.count(str))，
參數：str -- 分隔符，默認為所有的空字符，包括空格、換行(\n)、制表符(\t)等；
num -- 分割次數。默認為 -1, 即分隔所有。換句話說，split()當不帶參數時以空格進行分割，當代參數時，以該參數進行分割
'''
str = "hahaha_lalala_xixixi"
str_end = str.split('_')
# print(str_end) # ['hahaha', 'lalala', 'xixixi']
'''
題目：
有個列表 [“hello”, “world”, “yoyo”]如何把把列表⾥⾯的字符串聯起來，得到字符串 “hello_world_yoyo”
join() 方法用於將序列中的元素以指定的字符連接生成一個新的字符串
str.join(sequence)
'''
list = ["hello", "world", "yoyo"]
str = '_'
list1 = str.join(list)
print(list1) # hello_world_yoyo
'''
這邊如果不依賴python提供的join⽅法，我們還可以通過for循環，然后將字符串拼接，但是在⽤"+"連接字符串時，結果會⽣成新的對象，
⽤join時結果只是將原列表中的元素拼接起來，所以join效率⽐較⾼
'''
# 定義一個空字符串
j = ""
# 通過for循環打印列表中數據
for i in list:
print(i)
j = j + "_" + i
print(j)
# for 循環得到的是 _hello_world_yoyo，前⾯會多⼀個下划線，所以我們下⾯把這個下划線去掉
'''
lstrip() 方法用於截掉字符串左邊的空格或指定字符
str.lstrip([chars])
chars --指定截取的字符。
'''
j = j.lstrip('_')
print(j)
'''
題目：
把字符串 s 中的每個空格替換成”%20”
輸⼊：s = “We are happy.”
輸出：”We%20are%20happy.”
replace() 方法把字符串中的 old（舊字符串） 替換成 new(新字符串)，如果指定第三個參數max，則替換不超過 max 次。
str.replace(old, new[, max])
old -- 將被替換的子字符串。
new -- 新字符串，用於替換old子字符串。
max -- 可選字符串, 替換不超過 max 次
'''
s = "We are happy"
new_s = s.replace(' ', '%20')
print(new_s)
# 打印99乘法表
# for 實現
for i in range(1, 10):
for j in range(1, i + 1):
print('{}x{}={}\t'.format(j, i, i * j), end='')
print()
print('下面是while來實現')
# while 實現
i = 1
while i <= 9:
j = 1
while j <= i:
print("%d*%d=%-2d" % (i, j, i * j), end=' ') # %d 整數的占位符，-2表示靠左對齊，兩個占位符
j += 1
print()
i += 1
'''
題目：
找出單詞 “welcome” 在 字符串”Hello, welcome to my world.” 中出現的位置，找不到返回-1
find() 方法檢測字符串中是否包含子字符串 str ，如果指定 beg（開始） 和 end（結束） 范圍，則檢查是否包含在指定范圍內，如果指定范圍內如果包含指定索引值，返回的是索引值在字符串中的起始位置。
如果不包含索引值，返回-1。
str.find(str, beg=0, end=len(string))
str -- 指定檢索的字符串
beg -- 開始索引，默認為0。
end -- 結束索引，默認為字符串的長度。
'''
def test():
message = "Hello, welcome to my world."
world = 'welcome'
if world in message:
return message.find(world)
else:
return -1
# 統計字符串“Hello, welcome to my world.” 中字母w出現的次數，
def test1():
message = 'Hello, welcome to my world.'
# 計數
num = 0
# 循環message
for i in message:
if 'w' in i:
num += 1
return num
'''
字符串“Hello, welcome to my world.”,統計計單詞 my 出現的次數
replace 與split 組合使用 split()就是將一個字符串分裂成多個字符串，並以列表的形式返回
'''
str = "Hello, welcome to my world. my"
str1 = str.replace(',', '') # Hello welcome to my world.
str2 = str1.split()
for i in str2:
if i == 'my':
count = str2.count(i)
print(i, '出現次數：', count) # my 出現次數： 2
'''
輸⼊⼀個字符串str, 輸出第m個只出現過n次的字符，如在字符串 gbgkkdehh 中,找出第2個只出現1 次的字符，輸出結果：d
'''
def test3(str_test, num, counts):
'''
:param str_test: 字符串
:param num: 字符串出現的次數
:param counts: 字符串第幾次出現的次數
:return:
'''
# 定義一個空數組，存放邏輯處理后的數據
list = []
# for 循環字符串的數據
for i in str_test:
# 使用count函數，統計出所有字符串出現的次數
count = str_test.count(i, 0, len(str_test))
# 判斷字母在字符串中出現的次數與設置的counts的次數相同，則將數據存放在list數組中
if count == num:
list.append(i)
# 返回第n次出現的字符串
return list[counts - 1]
# 調用test3('gbgkkdehh',1,2) 得出d
'''
判斷字符串a=”welcome to my world” 是否包含單詞b=”world” 包含返回True，不包含返回 False
'''
def test4():
message = "welcome to my world"
world = "world"
if world in message:
return True
return False
'''
輸出指定字符串A在字符串B中第⼀次出現的位置,如果B中不包含A,則輸出-1
從 0 開始計數
A = “hello”
B = “hi how are you hello world, hello yoyo !
'''
def test5():
message = 'hi how are you hello world, hello yoyo !'
world = 'hello'
if world in message:
return message.find(world)
else:
return -1
'''
輸出指定字符串A在字符串B中最后出現的位置,如果B中不包含A, 出-1從 0 開始計數
A = “hello”
B = “hi how are you hello world, hello yoyo !”
'''
def test6(string, str):
# 定義last_position 初始值為-1
last_position = -1
while True:
position = string.find(str, last_position + 1)
if position == -1:
return last_position
last_position = position
# print(test6('hi how are you hello world, hello yoyo !','hello'))
'''
給定⼀個數a，判斷⼀個數字是否為奇數或偶數
a1 = 13
a2 = 10
'''
while True:
try:
# 判斷輸入是否為整數
num = int(input('輸入一個整數: '))
# 不是純數字需要重新輸入
except ValueError:
print("輸入的不是整數!")
continue
if num % 2 == 0:
print('偶數')
else:
print('奇數')
break
'''
輸⼊⼀個姓名，判斷是否姓王
a = “王五”
b = “⽼王”
'''
def test7():
user_input = input('請輸入您的姓名:')
if user_input[0] == '王':
return '用戶姓王'
else:
return '用戶不姓王'
'''
如何判斷⼀個字符串是不是純數字組成
a = “123456”
b = “yoyo123”
'''
def test8(num):
try:
return float(num)
except ValueError:
return '請輸入數字'
'''
將字符串 a = “This is string example….wow!” 全部轉成⼤寫
字符串 b = “Welcome To My World” 全部轉成⼩寫
'''
a = 'This is string example….wow!'
b = 'Welcome To My World'
print(a.upper())
print(b.lower())
'''
將字符串 a = “ welcome to my world “⾸尾空格去掉
python提供了strip()⽅法，可以去除⾸尾空格
rstrip()去掉尾部空格
lstrip（）去掉⾸部空格
replace(" ", “”) 去掉全部空格
'''
a = 'welcome to my world '
print(a.strip())
# 還可以通過遞歸的⽅式實現
def trim(s):
flag = 0
if s[:1] == '':
s = s[1:]
flag = 1
if s[-1:] == '':
s = s[:-1]
flag = 1
if flag == 1:
return trim(s)
else:
return s
'''
s = “ajldjlajfdljfddd”，去重並從⼩到⼤排序輸出”adfjl”
'''
def test9():
s = 'ajldjlajfdljfddd'
# 定義一個數組存放數據
str_list = []
# for 循環s字符串中的數據，然后將數據加入數組中
for i in s:
if i in str_list:
str_list.remove(i)
str_list.append(i)
# 使用sorted 方法 對字母進行排序
a = sorted(str_list)
# sorted 方法返回的是一個列表 這邊將列表數據轉換成字符串
return ''.join(a)
def test10():
'''
abs() 函數返回數字的絕對值
'''
n = 8
for i in range(-int(n / 2), int(n / 2) + 1): # -4 -3 -2 -1 0 1 2 3 4
print(" " * abs(i), "*" * abs(n - abs(i) * 2))
'''
題⽬ 給⼀個不多於5位的正整數，要求：
a = 12345
⼀、求它是⼏位數，
⼆、逆序打印出各位數字。
'''
class Test:
# 計算數字的位數
def test_num(self, num):
try:
# 定義一個length變量，來計算數字的長度
length = 0
while num != 0:
# 判斷num不等於0的時候，每次都除以10取整
length += 1
num = int(num) // 10
if length > 5:
return '請輸入正確的數字'
return length
except ValueError:
return '請輸入正確的數字'
# 逆序打印出數字
def test_sorted(self, num):
if self.test_num(num) != '請輸入正確的數字':
# 逆序打印出數字
sorted_num = num[::-1]
print(sorted_num)
# 返回逆序的個位數
return sorted_num
print(Test().test_num('12345'))
print(Test().test_sorted('12345'))
'''
題目：
如果⼀個 3 位數等於其各位數字的⽴⽅和，則稱這個數為⽔仙花數。
例如：153 = 1^3 + 5^3 + 3^3，因此 153 就是⼀個⽔仙花數
那么問題來了，求1000以內的⽔仙花數（3位數）
'''
def test():
str_list = []
for num in range(100, 1000):
i = num // 100
j = num // 10 % 10
k = num % 10
if i ** 3 + j ** 3 + k ** 3 == num:
# print(str(num) + '是水仙花數')
str_list.append(num)
return str_list # [153, 370, 371, 407]
'''
題目：
求1+2+3…+100和
'''
i = 1
for j in range(1, 101):
print(j)
i = j + i
print(i)
'''
題目：
計算求1-2+3-4+5-…-100的值
'''
def test(sum_to):
# 定義一個初始值
sum_all = 0
# 循環要計算的數據
for i in range(1, sum_to + 1):
sum_all += i * (-1) ** (1 + i)
return sum_all
'''
題目：
計算公式 13 + 23 + 33 + 43 + …….+ n3
實現要求：
輸⼊ : n = 5
輸出 : 225
對應的公式 : 13 + 23 + 33 + 43 + 53 = 225
'''
def test1(n):
sum = 0
for i in range(1, n + 1): # 1 2 3 4 5
sum += i * i * i
return sum
# test1(5) 225
'''
題目：
已知 a的值為”hello”，b的值為”world”，如何交換a和b的值？
得到a的值為”world”，b的值為”hello”
'''
a = 'hello'
b = 'world'
c = a
a = b
b = c
print(a, b)
'''
題目:
如何判斷⼀個數組是對稱數組：
要求：判斷數組元素是否對稱。例如[1，2，0，2，1]，[1，2，3，3，2，1]這樣的都是對稱數組
⽤Python代碼判斷，是對稱數組打印True，不是打印False,如：
x = [1, “a”, 0, “2”, 0, “a”, 1]
'''
def test2():
x = [1, 'a', 0, '2', 0, 'a', 1]
# 通過下標的形式，將字符串逆序進行對比
if x == x[::-1]:
return True
return False
print(test2())
'''
如果有⼀個列表a=[1,3,5,7,11]
問題：1如何讓它反轉成[11,7,5,3,1]
2.取到奇數位值的數字，如[1,5,11]
'''
def test():
a=[1,3,5,7,11]
# 逆序打印數組中的數據
b=a[::-1]
#print(b) [11, 7, 5, 3, 1]
list =[]
# 定義一個計數的變量
count =0
for i in a:
# 判斷每循環列表中的一個數據，則計數器會 +1
count+=1
#如果計數器為奇數，則打印
if count %2 !=0:
#print(i)
list.append(i)
return list
#print(test()) [1, 5, 11]
'''
問題：對列表a 中的數字從⼩到⼤排序
a = [1, 6, 8, 11, 9, 1, 8, 6, 8, 7, 8]
'''
# 方法一
a = [1, 6, 8, 11, 9, 1, 8, 6, 8, 7, 8]
b = sorted(a)
print(b)
# 方法二 冒泡排序
# for 循環控制比多少輪
for i in range(len(a)):
# 控制每輪減多少次
for j in range(len(a)-1-i):
# 判斷相鄰兩數的大小
if a[j] > a[j+1]:
#如果前面的數比后面的大，則兩數互換位置
a[j],a[j+1] = a[j+1],a[j]
print(a)
'''
L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
找出列表中最⼤值和最⼩值
'''
L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
# 方法一
print(max(L1))
print(min(L1))
# 方法二：
class Test(object):
def __init__(self):
# 測試的列表數據
self.L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
#從列表中取第一個值，對於數據大小比對
self.num =self.L1[0] # 1
def test_samll_num(self,count):
'''
:param count: 為1 表示計算最大值，為2時 表示最小值
:return:
'''
# for 循環查詢列表中的數據
for i in self.L1:
if count ==1:
#循環判斷當數組中的數據比初始值大，則將初始值替換
if i > self.num:
self.num =i
elif count ==2:
if i < self.num:
self.num =i
elif count !=1 or count !=2:
return '請輸入正確的數據'
return self.num
# new_test = Test()
# max_value = new_test.test_samll_num(1)
# min_value = new_test.test_samll_num(2)
'''
a = [“hello”, “world”, “yoyo”, “congratulations”]
找出列表中單詞最長的⼀個
'''
def test1():
a = ['hello','world','yoyo','congratulations']
# 統計數組中第一個值的長度
length= len(a[0])
for i in a:
print(i)
# 循環數組中的數據，當數組中的數據比初始值 length的值長 則替換length的默認值
if len(i) >length:
length =i
return length
# print(test1())
'''
取出列表中最⼤的三個值
L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
'''
L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
# 由小到大排序 [1, 2, 2, 2, 3, 3, 5, 5, 11, 33, 88]
L2 = sorted(L1)
#print(L2)
# 取最大的三個值
L3 = L2[8:11]
#print(L3) # [11, 33, 88]
'''
a = [1, -6, 2, -5, 9, 4, 20, -3] 按列表中的數字絕對值從⼩到⼤排序
'''
def test():
a = [1, -6, 2, -5, 9, 4, 20, -3]
# 定義一個數組，存放處理后的絕對值數據
lists = []
for i in a:
# 使用abs() 處理絕對值
i = abs(i)
lists.append(i)
print(lists) # [1, 6, 2, 5, 9, 4, 20, 3]
# 數字絕對值從小到大排序
# 方法一
lists = sorted(lists)
print(lists) # [1, 2, 3, 4, 5, 6, 9, 20]
# 方法二 冒泡排序
# 循環控制比多少輪
for i in range(len(lists)):
#控制每輪減多少次
for j in range(len(lists)-1-i):
# 相鄰兩數值比較大小
if lists[j] > lists[j+1]:
lists[j],lists[j+1] = lists[j+1],lists[j]
print(lists) # [1, 2, 3, 4, 5, 6, 9, 20]
'''
list = [“hello”, “helloworld”, “he”, “hao”, “good”]
按list⾥⾯單詞長度倒敘
考察字典排序
sorted函數，sorted(iterable,key,reverse)，sorted一共有iterable,key,reverse這三個參數
其中iterable表示可以迭代的對象，例如可以是dict.items()、dict.keys()等，key是一個函數，用來選取參與比較的元素，
reverse則是用來指定排序是倒序還是順序，
reverse=true則是倒序，
reverse=false時則是順序，默認時reverse=false。
list = [('helloworld', 10), ('hello', 5), ('good', 4), ('hao', 3), ('he', 2)]
按key值對字典排序 sorted(list.keys())
按value值對字典排序 sorted(list.items(),key=lamba item:item[1])
'''
def test1():
list_1 = ['hello', 'helloworld', 'he', 'hao', 'good']
count = {}
# 循環查看list中每個字符的長度
for i in list_1:
#將數據統計稱字典格式，字符串為鍵，字符串長度為值
count[i] = len(i)
list1 = sorted(count.items(),key=lambda item:item[1],reverse=True)
list3 =[]
for j in list1:
#print(j) # ('helloworld', 10)
# 循環 得到j，取key的值
list3.append(j[0])
#print(list3) # ['helloworld', 'hello', 'good', 'hao', 'he']
'''
L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
如何⽤⼀⾏代碼得出[1, 2, 3, 5, 11, 33, 88]
考察點：
sorted()
set() 函數 創建一個無序不重復元素集
'''
L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
L2 = sorted(set(L1))
#print(L2)
'''
將列表中的重復值取出(僅保留第⼀個)，要求保留原始列表順序
如a=[3, 2, 1, 4, 2, 6, 1] 輸出[3, 2, 1, 4, 6]
'''
a=[3, 2, 1, 4, 2, 6, 1]
lists = []
for i in a:
if i not in lists:
lists.append(i)
#print(lists) # [3, 2, 1, 4, 6]
'''
a = [1, 3, 5, 7]
b = [‘a’, ‘b’, ‘c’, ‘d’]
如何得到[1, 3, 5, 7, ‘a’, ‘b’, ‘c’, ‘d’]
'''
a = [1, 3, 5, 7]
b = ['a', 'b', 'c', 'd']
for i in b:
a.append(i)
# print(a) [1, 3, 5, 7, 'a', 'b', 'c', 'd']
'''
⽤⼀⾏代碼⽣成⼀個包含 1-10 之間所有偶數的列表
range(2,11,2) 起始值 2 ， 結束值 11 步長 2
'''
list1 = [i for i in range(2,11,2) if i%2 == 0]
# print(list) [2, 4, 6, 8, 10]
'''
列表a = [1,2,3,4,5], 計算列表成員的平⽅數，得到[1,4,9,16,25]
'''
a = [1,2,3,4,5]
list1 = []
for i in a:
list1.append(i*i)
# print(list) [1, 4, 9, 16, 25]
'''
使⽤列表推導式，將列表中a = [1, 3, -3, 4, -2, 8, -7, 6]
找出⼤於0的數，重新⽣成⼀個新的列表
'''
a = [1, 3, -3, 4, -2, 8, -7, 6]
list2 = []
for i in a :
if i >0:
list2.append(i)
# print(list) [1, 3, 4, 8, 6]
'''
統計在⼀個隊列中的數字，有多少個正數，多少個負數，如[1, 3, 5, 7, 0, -1, -9, -4, -5, 8]
'''
list3 = [1, 3, 5, 7, 0, -1, -9, -4, -5, 8]
count = 0 # 計算正數
num = 0 # 計算負數
for i in list3:
# i >0 正數
if i >0:
count+=1
# 負數
elif i<0:
num+=1
#print(count) 5
#print(num) 4
'''
a = [“張三”,”張四”,”張五”,”王⼆”] 如何刪除姓張的
⽤[:]或[::]對多數序列類型（可變的或不可變的）（如字符串、列表等）序列中元素進⾏截取。
'''
a = ["張三","張四","張五","王⼆","王五"]
for i in a[:]:
if i[0] == '張':
a.remove(i)
# print(a) ['王⼆', '王五']
'''
有個列表 a = [1, 3, 5, 7, 0, -1, -9, -4, -5, 8] 使⽤filter 函數過濾出⼤於0的數
列表 b = [“張三”, “張四”, “張五”, “王⼆”] 過濾掉姓張的姓名
newIter = filter(function, iterable)
其中，各個參數的含義如下：
function：可傳遞一個用於判斷的函數，也可以將該參數設置為 None。
iterable：可迭代對象，包括列表、元組、字典、集合、字符串等。iterable:可迭代對象
newIter：在 Python 2.x 中，該函數返回過濾后得到的新列表；而在 Python 3.x 中，該函數返回一個迭代器對象，可以用 list()、tuple() 等方法獲取過濾后得到的新序列。
list()函數是Python的內置函數。它可以將任何可迭代數據轉換為列表類型，並返回轉換后的列表。當參數為空時，list函數可以創建一個空列表
'''
a = [1, 3, 5, 7, 0, -1, -9, -4, -5, 8]
def test(a):
return a > 0
list1 = filter(test,a)
list1 = list(list1)
#print(list1)
b = ["張三", "張四", "張五", "王⼆"]
def test_1(b):
# print(b[0]) 取出的是 姓 張 、張 、張 、王
return b[0] !='張'
#print(list(filter(test_1,b)))
'''
過濾掉列表中不及格的學⽣
a = [
{“name”: “張三”, “score”: 66},
{“name”: “李四”, “score”: 88},
{“name”: “王五”, “score”: 90},
{“name”: “陳六”, “score”: 56},
]
'''
a = [
{"name": "張三", "score": 66},
{"name": "李四", "score": 88},
{"name": "王五", "score": 90},
{"name": "陳六", "score": 56},
]
ls = filter(lambda e:e['score'] > 60,a)
ls = list(ls)
#print(ls)
'''
獲得成績在 600 分到 700 分之間的學生信息
'''
lst1 = [
("小明",600),("小明1",602),("小明2",602),("小明3",524),("小明4",716),("小章",624),("小白",635)
,("小趙",480),("小高",580),("小王",541),("小芳",680)
]
def find(lst1):
score = int(lst1[1])
if 600 <= score <700 :
return True
else:
return False
new_lst1 = filter(find,lst1)
new_lst1 = list(new_lst1)
# print(new_lst1)
'''
有個列表 a = [1, 2, 3, 11, 2, 5, 88, 3, 2, 5, 33]
找出列表中最⼤的數，出現的位置，下標從0開始
'''
def test_max():
a = [1, 2, 3, 11, 2, 5, 88, 3, 2, 5, 33]
# 最大值
a_max = max(a)
# 定義一個計數器，每次循環一個數字的時候，計數器 +1 用於記錄數字的下標
count = 0
for i in a:
count +=1
if i == a_max:
break
return count-1
#print(test_max())
'''
a = [
‘my’, ‘skills’, ‘are’, ‘poor’, ‘I’, ‘am’, ‘poor’, ‘I’,
‘need’, ‘skills’, ‘more’, ‘my’, ‘ability’, ‘are’,
‘so’, ‘poor’
]
找出列表中出現次數最多的元素
'''
a = [
'my', 'skills', 'are','poor','I','am','poor','I',
'need','skills','more','my','ability','are','so','poor'
]
def test_more():
dicts ={}
for i in a:
#統計數組中每個字符串出現的次數，將數據存放到字典中
if i not in dicts.keys():
dicts[i]=a.count(i)
# 找到字典中最大的key
dicts_1 = sorted(dicts.items(),key=lambda e:e[1],reverse=True) # [('poor', 3), ('my', 2), ('skills', 2), ('are', 2), ('I', 2), ('am', 1), ('need', 1), ('more', 1), ('ability', 1), ('so', 1)]
return dicts_1[0][0]
# print(test_more())
'''
給定⼀個整數數組A及它的⼤⼩n，同時給定要查找的元素val，
請返回它在數組中的位置(從0開始)，若不存在該元素，返回-1。
若該元素出現多次請返回第⼀個找到的位置
如 A1=[1, “aa”, 2, “bb”, "3",“val”, 33]
或 A2 = [1, “aa”, 2, “bb”]
'''
A1=[1, 'aa', 2, 'bb',3, 'val', 33]
def test_find(lists,findStr):
'''
:param lists: 數組
:param findStr: 要查找的元素
:return:
'''
# 判斷字符串不在數組中，返回 -1
if findStr not in lists:
return -1
# 初始位置 0，循環一次 +1
count =0
for i in lists:
count+=1
if i == findStr:
return count-1
'''
給定⼀個整數數組nums 和⼀個⽬標值target ，請你在該數組中找出和為⽬標值的那兩個整數，並返回他們的數組下標。
你可以假設每種輸⼊只會對應⼀個答案。但是，數組中同⼀個元素不能使⽤兩遍。
⽰例:
給定nums=[2，7，11，15]，target=9
因為nums[0] + nums[1] =2+7 = 9
所以返回[0，1]
'''
def test(target=9):
num = [2, 7, 11, 15]
length = len(num)
dicts = {}
for i in range(length):
for j in range(i+1,length):
dicts.update({num[i] + num[j]: {i, j}})
lists = []
for nums in dicts[target]:
lists.append(nums)
return lists
# print(test()) [0, 1]
'''
a = [[1,2],[3,4],[5,6]] 如何⼀句代碼得到 [1, 2, 3, 4, 5, 6]
'''
a = [[1,2],[3,4],[5,6]]
# 定義一個新數組存放數組
lists = []
for i in a:
#print(i) # [1, 2]
for j in i:
lists.append(j)
# print(lists) # [1, 2, 3, 4, 5, 6]
'''
⼆維數組取值(矩陣),有 a = [[“A”, 1], [“B”, 2]] ，如何取出 2
import numpy as np
np.array(x)：將x轉化為一個數組
np.array(x,dtype)：將x轉化為一個類型為type的數組
'''
import numpy
a = [["A", 1], ["B", 2]]
arr = numpy.array(a)
# print(arr) # [['A' '1'] ['B' '2']]
# print(arr[1,1]) # 2
'''
輸出1-100除3余1 的數，結果為tuple
'''
tuple =()
for i in range(1,101):
# 判斷除以3余1的數
if i %3 ==1:
# 將數據加入元組中
tuple +=(i,)
print(tuple)
'''
a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 c = [(1,),(2,),(3,) ] 的區別？
'''
a =[1,2,3] # 正常的列表
b =[(1),(2),(3)] # 雖然列表的每個元素加上了括號，但是當括號內只有⼀個元素並且沒有逗號時，其數據類型是元素本⾝的數據類型
b =[(1,),(2,),(3,)] # 列表中的元素類型都是元組類
'''
map函數,有個列表a = [1, 2, 3, 4] 計算列表中每個數除以2 取出余數 得到 [1,0,1,0]
'''
def map():
a = [1,2,3,4]
lists = []
for i in a:
lists.append(i % 2)
return lists
print(map())
'''
map函數將列表 [1,2,3,4,5] 使⽤python⽅法轉變成 [1,4,9,16,25]
'''
def map():
a = [1,2,3,4,5]
lists = []
for i in a:
lists.append(i * i)
return lists
print(map())
'''
兩個字典合並a={“A”:1,”B”:2},b={“C”:3,”D”:4}
'''
a = {"A" : 1,"B" : 2}
b = {"C" : 3, "D":4}
a.update(b)
print(a)
'''
函數計算10！(10的階乘) 10！ = 1 x 2 x 3 x ... x 10 = 3628800
1的階乘：1
2的階乘：2
3的階乘：6
4的階乘：24
5的階乘：120
6的階乘：720
7的階乘：5040
8的階乘：40320
9的階乘：362880
10的階乘：3628800
一個正整數的階乘是所有小於及等於該數的正整數的積，自然數n的階乘寫作n!
'''
def f(num):
if num == 1 or num == 0:
return 1
else:
# 利用遞歸方式實現
return num * f(num - 1)
print(f(10))
'''
有1、2、3、4數字能組成多少互不相同⽆重復數的三位數?
分別打印這些三位數的組合
'''
lst = ["1" , "2" ,"3" ,"4"]
length = len(lst)
for i in range(length):
for j in range(length):
for k in range(length):
if i !=j and j !=k and i !=k:
print(lst[i] + lst[j] + lst[k])
原文可看：https://wenku.baidu.com/view/ac330c626aeae009581b6bd97f1922791688be34
