目錄

一、運算子

二、公共操作

三、迴圈

四、函式

五、推導式

六、遞迴&匿名函式

七、內建高階函式

八、常見資料結構

一、運算子

#資料型別
age = 18
name = 'TOM'
weight = 75.5
stu_id = 1
print('今年我的年齡是%d歲' % age)
print('我的名字是%s' % name)
print('我的體重是%.1f公斤' % weight)
print('我的學號是%03d' % stu_id)
print('我的名字是%s，今年%d歲了' % (name,age))

#列印更高效 
print(f'我的名字是{name}，今年{age}歲了
 
')
print('hello\nworld')
print('a\tb\tc\td')
print('hello world',end="...")

# 註釋 ctrl+ /
"""
print('where')
"""
'''
print('are')
'''
#輸入
#password = input("請輸出密碼：")
#print(f'您輸入的密碼是{password}')
#print(type(password))
#print(type(int(password)))

#運算
print(10//3)#取整
print(10%3)#取模
print(10**2)#指數

#多變數賦值
num1,float1,str1 = 10, 0.5 ,'
 
yep'
print(num1)
print(float1)
print(str1)
c= 10
c *= 1 + 2
print(c)

#邏輯運算
#and運算子，只要有一個值為0，則結果為0，否則返回最後一個非0數字
#or運算子，只有所有值為0結果才為0，否則返回第一個非0數字
a = 0
b = 1
c = 2
print(b and c)
print(a or c)

#三目運算子
a = 10
b = 6
c = a - b if a > b else b - a
print(c)

二、公共操作

# 公共操作（運算子、公共方法、容器型別轉換）
str1 = 'aa'
str2 = '
 
bb'

list1 = [1,2]
list2 = [10,20]

t1 = (1,2)
t2 = (10,20)

dict1 = {'name':'Python'}
dict2 = {'age':'30'}

# +：合併，支援字串、列表、元組
print(str1 + str2)
print(list1 + list2)
print(t1 + t2)
#print(dict1 + dict2)

# *: 複製，支援字串、列表、元組
print(str1 * 5)
print(list1 * 5)
print(t1 * 5)
#print(dict1 * 5)

# len計算元素個數
print(len(str1))
print(len(list1))
print(len(t1))
print(len(dict2))

# del 或 del() 刪除
# max(),min()
print(max(str1))

# range(start,end,step)
for i in range(1,10,1):
print(i)

# enumerate(可遍歷物件，start=0) 返回結果是元組，第一個是下標，第二個是資料
list1 = [1,2,3,4]

for i in list1:
print(i)
for i in enumerate(list1):
print(i)
for key，value in enumerate(list1,start = 1):
print( key，value)

# 容器轉換
# tuple() 轉成元組
# list() 轉成列表
# set() 轉成集合

三、迴圈

#隨機數
import random as rd
print (rd.randint(0,2))

#while迴圈
i = 0
while i < 5:
print('媳婦我錯了')
i += 1

#break 終止此迴圈

#continue 退出當前迴圈，開始下一個迴圈

#pass 跳過

#列印長方形
j = 0
while j < 5:
k = 0
while k < 5:
print('*' ,end=' ')
k += 1
print()
j +=1

#列印三角形
i = 0
while i < 5:
j = 0
while(j <= i):
print('*' ,end=' ')
j += 1
print()
i += 1

#列印乘法表
i = 1
while i <= 9:
j = 1
while(j <= i):
# print(f'{j} * {i} = {i*j}',end = '\t')
print('%d * %d = %d' %(j,i,i*j),end = '\t')
j += 1
print()
i += 1

四、函式

# 函式
def sel_func():
print('顯示餘額')
print('取款')
print('存款')

print('恭喜你登入成功')
sel_func()

print('您的餘額是1000000')
sel_func()

print('取了1000')
sel_func()

# 全域性變數
global num

# 位置引數：順序和數量要一致

# 關鍵字引數：如果有位置引數，必須在位置引數後，數量一致，關鍵字引數的順序沒有要求

# 預設引數

# 不定長位置引數，返回一個元組

def user_info(*args):
print(args)

user_info('Tom')
user_info('Tom',18)

# 不定長關鍵引數，返回一個字典
def user_info(**args):
print(args)

user_info(NAME='Tom',AGE=28,SEX='男')

# 字典拆包
dict1 = {'name':'Tom','age':18}
a,b = dict1
print(a)
print(b)
print(dict1[a])
print(dict1[b])

# 交換變數
a, b = 1, 2
a, b = b, a
print(a,b)

# 引用，在py中，值是靠引用來傳遞的

# id()：那塊記憶體的地址標識
a = 1
b = a
print(id(a))
print(id(b))
a = 2
print(id(a))
print(id(b))

aa = [10,20]
bb = aa
print(id(aa))
print(id(bb))
aa = [30,40]
print(id(aa))
print(id(bb))

# 引用可以當做實參傳入

# 內建函式
絕對值 abs()
冪函式 pow(x,y) 即 x的y次冪

# math包函式
平方根 math.sqrt(4) = 2

五、推導式

# 推導式（化簡程式碼）支援列表、字典、集合

# 一、列表推導式，
# 建立一個0-10的列表
# 1.迴圈實現
list1 = []
i = 0
while i < 10:
list1.append(i)
i += 1
print(list1)

list1 = []
for i in range(0,10):
list1.append(i)
i += 1
print(list1)

# 2.列表推導式
list1 = [i for i in range(10)]
print(list1)

# 建立0-10的偶數列表
list2 = [i for i in range(0,10,2)]
print(list2)

list3 = [i for i in range(0,10,2) if i % 2 == 0]
print(list3)

# 多個for迴圈實現列表推導式
# [(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)]
# 資料1:1,2 range(1,3)
# 資料2:0,1,2 range(0,3)
list3 = [(i,j) for i in range(1,3) for j in range(3)]

# 二、字典推導式
# 建立一個字典，key是1-5，value是key的二次方
dict1 = {i:i**2 for i in range(1,6)}
print(dict1)

# 將兩個列表合併為一個字典
list1 = ['name','age','gender']
list2 = ['Tom',20,'man']
dict1 = {list1[i]:list2[i] for i in range(len(list1))}
print(dict1)

# 如果兩個列表的資料個數不同，按len少的列表資料為準

# 三、集合推導式
list1 = [1,1,2]
set1 = {i ** 2 for i in list1}
print(set1)

六、遞迴&匿名函式

# 遞迴：函式內部自己呼叫自己、必須有出口
def sum_numbers(num):
if num == 1:
return 1
return num + sum_numbers(num -1)

result = sum_numbers(10)
print(result)

# lambda：（匿名函式）如果一個函式有一個返回值，並且只有一句程式碼，可以用lambda簡化
fn2 = lambda: 100
print(fn2)
print(fn2())

fn1 = lambda a,b: a + b
print(fn1(1,2))

# 可變引數*args,返回元組
fn3 = lambda *args: args
print(fn3(10,20,30))
print(fn3(10))

# 可變引數*kwargs，返回字典
fn4 = lambda **kwargs: kwargs
print(fn4(name='Python'))
print(fn4(age=30))

# 帶判斷的lambda
fn5 = lambda a,b:a if a > b else b
print(fn5(120,119))

# 列表資料按字典key值排序
students = [
{'name':'Tom','age':18},
{'name':'Jack','age':20},
{'name':'wuchen','age':19}
]
info = students.sort(key = lambda x:x['age'],reverse = True)
print(students)

七、內建高階函式

#1. 高階函式 abs(),round()
def sum(a,b,f):
return f(a) + f(b)
print(sum(-1,5,abs))
print(sum(1.1,2.1,round))

#2. 內建高階函式 map(func,lst) 將傳入的函式變數作用到lst變數的每個元素中，並將結果組成新的迭代器返回
做文字處理的時候，假如要對序列裡的每個單詞進行大寫轉化操作。
這個時候就可以使用map()函式。
chars = ['apple','watermelon','pear','banana']
a = map(lambda x:x.upper(),chars)
print(list(a))

# 輸出：['APPLE', 'WATERMELON', 'PEAR', 'BANANA']
map()會根據提供的函式，對指定的序列做對映，最終返回迭代器。
也就是說map()函式會把序列裡的每一個元素用指定的方法加工一遍，最終返回給你加工好的序列。
舉個例子，對列表裡的每個數字作平方處理：
nums = [1,2,3,4]
a = map(lambda x:x*x,nums)
print(list(a))
# 輸出：[1, 4, 9, 16]

#3. 內建高階函式 reduce(func,lst)，其中func必須喲兩個引數，每次func計算的結果繼續和序列的下一個元素做累積計算
前面說到對列表裡的每個數字作平方處理，用map()函式。
那我想將列表裡的每個元素相乘，該怎麼做呢？
這時候用到reduce()函式。
from functools import reduce
nums = [1,2,3,4]
a = reduce(lambda x,y:x*y,nums)
print(a)

# 輸出：24
reduce()會對引數序列中元素進行累積。
第一、第二個元素先進行函式操作，生成的結果再和第三個元素進行函式操作，以此類推，最終生成所有元素累積運算的結果。
再舉個例子，將字母連線成字串。
from functools import reduce
chars = ['a','p','p','l','e']
a = reduce(lambda x,y:x+y,chars)
print(a)

# 輸出：apple
你可能已經注意到，reduce()函式在python3裡已經不再是內建函式，而是遷移到了functools模組中。
這裡把reduce()函式拎出來講，是因為它太重要了。

#4. 內建高階函式 filter(func,lst)，用於過濾序列，過濾掉不符合條件的元素，返回一個filter物件
list1 = [1,2,3,4,5,6,7,8,9,10]
def func(x):
return x % 2 == 0
result = filter(func,list1)
print(result)
print(list(result))

#5.set()
當需要對一個列表進行去重操作的時候，set()函式就派上用場了。集合物件建立後，還能使用並集、交集、差集功能。
A = set('hello')
B = set('world')
A.union(B) # 並集，輸出：{'d', 'e', 'h', 'l', 'o', 'r', 'w'}
A.intersection(B) # 交集，輸出：{'l', 'o'}
A.difference(B) # 差集，輸出：{'d', 'r', 'w'}

#6.eval()
eval(str_expression)作用是將字串轉換成表示式，並且執行。
a = eval('[1,2,3]')
print(type(a))
# 輸出：<class 'list'>
b = eval('max([2,4,5])')
print(b)
# 輸出： 5

#7.sorted()
在處理資料過程中，我們經常會用到排序操作，比如將列表、字典、元組裡面的元素正/倒排序。
這時候就需要用到sorted()，它可以對任何可迭代物件進行排序，並返回列表。
對列表升序操作：
a = sorted([2,4,3,7,1,9])
print(a)
# 輸出：[1, 2, 3, 4, 7, 9]
對元組倒序操作：
sorted((4,1,9,6),reverse=True)
print(a)
# 輸出：[9, 6, 4, 1]
使用引數：key，根據自定義規則，按字串長度來排序：
chars = ['apple','watermelon','pear','banana']
a = sorted(chars,key=lambda x:len(x))
print(a)
# 輸出：['pear', 'apple', 'banana', 'watermelon']
根據自定義規則，對元組構成的列表進行排序：
tuple_list = [('A', 1,5), ('B', 3,2), ('C', 2,6)]
# key=lambda x: x[1]中可以任意選定x中可選的位置進行排序
a = sorted(tuple_list, key=lambda x: x[1]) 
print(a)
# 輸出：[('A', 1, 5), ('C', 2, 6), ('B', 3, 2)]

#8.reversed()
如果需要對序列的元素進行反轉操作，reversed()函式能幫到你。
reversed()接受一個序列，將序列裡的元素反轉，並最終返回迭代器。
a = reversed('abcde')
print(list(a))
# 輸出：['e', 'd', 'c', 'b', 'a']
b = reversed([2,3,4,5])
print(list(b))
# 輸出：[5, 4, 3, 2]

#9.filter()
一些數字組成的列表，要把其中偶數去掉，該怎麼做呢？
nums = [1,2,3,4,5,6]
a = filter(lambda x:x%2!=0,nums)
print(list(a))
# 輸出：[1,3,5]
filter()函式輕鬆完成了任務，它用於過濾序列，過濾掉不符合條件的元素，返回一個迭代器物件。
filter()函式和map()、reduce()函式類似，都是將序列裡的每個元素對映到函式，最終返回結果。
我們再試試，如何從許多單詞裡挑出包含字母w的單詞。
chars = chars = ['apple','watermelon','pear','banana']
a = filter(lambda x:'w' in x,chars)
print(list(a))
# 輸出：['watermelon']

#10.enumerate()
這樣一個場景，同時打印出序列裡每一個元素和它對應的順序號，我們用enumerate()函式做做看。
chars = ['apple','watermelon','pear','banana']
for i,j in enumerate(chars):
    print(i,j)
'''
輸出：
0 apple
1 watermelon
2 pear
3 banana
'''
enumerate翻譯過來是列舉、列舉的意思，所以說enumerate()函式用於對序列裡的元素進行順序標註，返回(元素、索引)組成的迭代器。
再舉個例子說明，對字串進行標註，返回每個字母和其索引。
a = enumerate('abcd')
print(list(a))
# 輸出：[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]

八、常見資料結構

1. 陣列：Array

2. 連結串列：Linkedlist

3. 雜湊表：HashTable

4. 佇列：Queue

5. 堆：Heap

6. 棧：Stack

7. 集合：Set