////////////////////////////////////////////// Thư viện ///////////////////
- import math : thư viện liên quan đến toán và sử dụng như lấy giá trị pi....
- encodeing='utf-8' : Sử dụng việt mã hóa để utf-8 để đọc được file tiếng việt.
- with {Hàm}() as {file,seesion,conn...} : Nó cho phép bạn sử dụng để tự động hóa quản lý tài nguyên.
////////////////////////////////////////////// Các câu gợi ý /////////////////// # : Conment 1 dòng '''{Conment}''' : Conment nhiều dòng \ : tiếp tục nhiều dòng khi hàm quá dài có thể dùng \ để xuống dòng rồi viết tiếp \n : xuống dòng \t tab trắng
- Trong python cho phép bạn dùng chỉ số âm ( arr[-1])
////////////////////////////////////////////// Các Hàm quan trọng /////////////////// - isinstance(,<kiểu>) : cho phép bạn kiểm tra có phải số cần kiểu không.
# Kiểm tra xem một số có phải là số nguyên không
x = 10
print(isinstance(x, int)) # Output: True - enumerate(): Lấy chỉ số và và gía trị trọng For
- strip() : Loại bỏ khoảng trắng và xuống dòng
- rstrip() : xóa một phần tử nào đó trong dòng file
- index() : Trả về index của một array,ob,list...
-sum()
row_count = sum(1 for _ in reader) # doc file trong dem so dong , cung co the tinh tonghttps://gemini.google.com/app/055b30eb7b1b185e?hl=vi
//////////////////////////////////////////////String ///////////////// - string( , , ) : Cắt chuỗi - in : Tìm kiếm chuỗi trả về true false
# string
a='0123456789'
print(a[3:6])
# in
a='thanh tung tim kiem'
a1='tim kiem'
b= a1 in a
print(b) # true - capitalize() : Viết hoa chữ cái đầu tiên
- upper() : Viết hoa toàn bộ
- lower() : Viết thường toàn bộ
- split() : Tách các chuỗi thành một chuỗi nhỏ
- join() : Thêm chuỗi
- replace(): Thay thế chuỗi
- find() : tìm vị trí xuất hiện đầu tiên trong chuỗi
- startswith() : Kiểm tra chuỗi có bắt đầu bằng chuỗi con cụ thể không
- endswith() : Kiểm tra xem chuỗi có kết thúc bằng chuỗi con cụ thể không
- count() : Đếm số lần
-
-isalnum() : True khi string là cả số và chữ
-isalpha() : True khi string là a-z|False không phải alpha a-z
-isdigit() : Trả về true khi string đó là số | False string là số
-islower() : True khi tất cả string trong chuỗi chữ thường | False là không phải chữ thường
-isspace() : True khi tất cả string là khoảng trắng | False ngươc lai
-isupper() : True khi tất cả string trong chuỗi chữ hoa | False là không phải chữ hoa
----------------------------Ham nang cao ----------------
-sreach() : Tìm kiếm chuỗi
- map() : Cho phép bạn chuyển đổi dữ liệu dàn list và kiểu dữ liệu khác ...
- re.findallP(<CanTim> , <Sring>) : Tìm số lần xuất hiện trong một chuỗi
- re.finditer(<Cần_tìm> , <String> ) : Tìm kiếm lọc ra các số.....
# finditer()
import re
a='2004-09-20'
c= re.finditer('-',a)
for num in c :
print(num.start()) - float('inf') : Số vô cùng lớn ===> Dùng trong không cần đặt một giá trị nhất định
- float('-inf') : Số vô cùng bé ===> Dùng trong không cần đặt một giá trị nhất định
////////////////////////////////////////////// Toán học /////////////////// + phép cộng - phép trừ * phép nhân ** phép chia lũy thừa / phéo chia lấy so thap phan // phéo chia nguyên % phép chia lấy phần dư
------------------------------------------Toán tử -------------------------------------- and : sử dụng kết hợp điều kiện cả hai cùng đúng thì đúng. or : Sử dụng kết hợp điều kiện một trong hai đúng là đc not : là điều kiện phủ định (true --> False | False --> True)
int() : kiểu số nguyên
float(): kiểu số thực
------------------------------------------Hàm liên quan đến Toán -------------------------
- pow({Số1},{Số2}) : Cho phép bạn tính số mũ
- round({số_thập_phân}, {lấy_sau_số_phẩy}) : cho phép bạn lấy số thập phân
- :.2f : Làm tròn sau hai chữ số thập phân(* Lưu ý: 2f chỉ được dùng trực tiếp khi in ra)
- format() :Định dạng ở 2 số thập phân
<!-- Vd format
txt = "For only {price:.2f} dollars!"
print(txt.format(price = 49))
-->
# ////////// pow
print(pow(2,3))
# KQ: 8
# ////////// round
print(round(23.4756775465,2))
# KQ: 23.47
# ////////// :.2f
num=34345.576576
print(f'{num:.2f}')
# KQ: 34345.58////////////////////////////////////////////// Vòng lặp ///////////////////
- for x in range({Start},{Stop},{step}) : Vòng lặp
- for x in y : lặp trong arr
- for x in enumerate(y) : lấy chỉ số index và lặp lại trong array
# Lặp vòng lặp khi biết trước số vòng lặp
# step
for x in range(3):
print(f'Vòng lặp:{x}')
# ==> KQ: lặp lại 3 lần
arr=[2,3,4]
# ///// start, stop
for x in range(1,3):
print(f'Vòng lặp:{x}')
# ==> KQ: lặp lại 3 lần
arr=[2,3,4]
# ///// start, stop,step
for x in range(1,3,1):
print(f'Vòng lặp:{x}')
# ==> KQ: lặp lại 3 lần
arr=[2,3,4]
# Lặp vòng lặp không biết vòng lặp nhất định
for x in arr:
print(f'Vòng lặp Arr:{x}')
# ==> KQ: lặp lại 3 lần in ra lần lượt các số trong mảng
# lặp và lấy chỉ số index
fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
print(f"Index: {index}, Fruit: {fruit}")
# ===> Sự khác nhau của for in và for in range() và for in enumerate() là:
# +For in: là lặp trong mảng
# +For in range() : lặp đi lặp lại các số chuyền trong range(y)
# +For in enumarate : lặp để lấy dữ liệu trong mảng và lấy cả index chỉ số của nó - while : Vòng lặp
# chạy vòng lặp while
n= 0
while n < 8:
n+=1;
# chạy vòng lặp true:
while(True):
# Vòng lặp chạy cho đến khi =////////////////////////////////////////////// Câu điều kiện /////////////////// if( a==b):
elif ( a==c):
else:
pass
////////////////////////////////////////////// List (array list) ///////////////////
- list() : Cho phép bạn tạo danh sách trong pythonv ( sử dụng giống như arr)
- Khai báo nó bằng []
: [<start>:<end>] ==> cho phép bạn lát cắt trong python
: [<item>] ==> Lấy ví trị trong list
: [<vitri>::<step>] ==> Cho phép bạn bắt đầu vị trí và lấy trong danh sách
- del(<item>) : Xóa phần tử trong list - append(<item>) : Thêm vào trong list
- insert(<index>,<item>) : THêm một phần tư vào một vị trí được chỉ định và các chỉ số khác sẽ đc +1 <item>
- sort() : Sắp xếp theo thứ tự tăng dần
- remove(<giaTriChoTruoc>) : Xóa phần tử được giá trị cho trước
- pop(<item>) : Xóa phần tư tại vi tri truyèn vao
- reverse() : đảo ngược danh sách list - clear() : Xóa tất cả các phần tử
////////////////////////////////////////////// tuple /////////////////// - Sử dụng tuple cho phép bạn không thay đổi được giá trị. - Khai báo nó bằng dấu ()
////////////////////////////////////////////// Array (mảng arr) ///////////////////
Arr : là kiểu mảng được khai báo.
len() : kiểm tra độ dài của mảng, của kí tự....
append() : Thêm phần tử vào mảng
insert() : Thêm phần tử vào trong mảng vào một vị trí bất kì
extend() : Thêm một mảng khác vào cuối danh sách phần tử trong mảng trước đó
pop() : Xóa phần tử
remove() : Cũng là xóa phần tử (có thử sử dụng một trong hai để xóa phần tử)
clear() : Xóa bỏ tất cả trong mảng
count() : Đếm số lần xuất hiện trong mảng
index() : Đếm chỉ số trong mảng
reverse(): Đảo ngược mảng trong phần tử
sort() : Sắp xếp các phần tử trong mảng
link : https://www.w3schools.com/python/python_arrays.asp
===> Sự khác nhau của list và array: + List: cho phép bạn thêm được nhiều kiểu dữ liệu khác nhau trong cùng một list. Chạy chậm hơn + Array: Lưu trữ đc 1 kiểu dữ liệu trong 1 arays. Chạy nhanh hơn list
////////////////////////////////////////////// dicnation (gần như json ) /////////////////// - Sử dụng bằng {} | ngoài ra nó cho phép bạn thay đổi được giá trị của nó - get() : Lấy giá trị trong tử điển - set() : trả về kiểu set (Xem bên dưới ) - update(): - not in : Kiểm tra không tồn tại - in Kiểm tra có tồn tại k. - values() : lấy key - item() : Lấy cả khóa và giá trị - len () : Lấy về số lượng phần tử trong Diacnation - pop(): - popitem() - del() - clear()
d={
1:"Thanhtung",
2:"Class"
}
print(d[1])# output "Thanhtung////////////////////////////////////////////// json (gần như dicnation ) ///////////////////
////////////////////////////////////////////// set /////////////////// - Nó tự động loại bỏ lặp phần tử trong Set - Sử dụng bằng {} + len() : Lấy số phần tử + add() : Thêm phần tử + remove(<Giá_trị>) : Xóa một giá trị nòa đó + discard(<Giá_trị>): Xóa phần tử và không báo lỗi khi k tìm thấy + in : Kiêm tra có tồn tại không ( True | False) + not in : Kiêm tra không tồn tại không ( True | False) - Phép toán trong Set() - Phép giao: chỉ hiện a và b xuất hiện cùng nhau thì hiện ra & <Tập_hợp_A>.intersection(<tập_hợp_B>) - Phép hợp : Cho phép bạn gộp a và b vào một set | : Phép hợp của hai phần tử <Tập_hợp_A>.union(<tập_hợp_B>) : phép hợp của hai phần tử - Phép Trừ : Chỉ thuộc A và không không thuộc b ( có hai cách sử dụng) - : <Tập_hợp_A>.difference(<tập_hợp_B>) - Phép đối xứng : # Phần tử chỉ có trong một trong hai set, không có trong cả hai ^ : Phép đối xứng <tập_hơpA>.symmetric_diference(<Tập_hơpB>)
== >
# VD1
set1={1,2,1,3,4}
print(set1)# ouput 1,2,3,4
# VD2
list1=[1,2,4,5,1]
print(set(list1))# ouput {1,2,4,5}
# ham hay dung
my_set.add(5) # Thêm phần tử 5 vào set
my_set.remove(3) # Xóa phần tử 3 khỏi set (nếu không tồn tại sẽ báo lỗi)
my_set.discard(6) # Xóa phần tử 6 nếu có, không báo lỗi nếu không tồn tại
# Phép toán trong Set()
# Phép hợp
set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2) # Kết quả: {1, 2, 3, 4, 5}
# phép giao
intersection_set = set1.intersection(set2) # Kết quả: {3}
# phép hiẹu ( phép trừ)
difference_set = set1.difference(set2) # Phần tử có trong set1 nhưng không có trong set2
# Kết quả: {1, 2}
# phép đối xứng
symmetric_difference_set = set1.symmetric_difference(set2)
# Phần tử chỉ có trong một trong hai set, không có trong cả hai
# Kết quả: {1, 2, 4, 5}////////////////////////////////////////////// Hàm def(function) + object- class /////////////////// def <dặt_tên_hàm> (<tham_chieu>):
lambda : Hàm này là cho phép bạn định nghia def (function) một cách đơn giản hơn, ngan gon(logic cao)
-----> Hàm sinh ra để giup ta xay dựng phát triển và tái sử dụng một cách đơn giản hơn!
////////////////////////////////////////////// Hàm /////////////////// - global : Biến toàn cục sẽ sử dụng cho phép bạn sử dụng. Khi sử dụng biến toàn cầu để thay gán đc giá trị bên trong ra bên ngoài.
# Global
count = 0
def increment():
global count
count += 1
increment()
increment()
print(count) # Output: 2////////////////////////////////////////////// Class (OPP huong doi tuong) /////////////////// - class <dat_ten> : --> Cho phép bạn lập trình opp
- super() : Cho phép bạn sử dụng lại các Claas cha trong thằng con
////////////////////////////////////////////// Module Random /////////////////// - random.randrange(start, stop, step): Tạo số nguyên ngẫu nhiên trong một khoảng với bước nhảy nhất định. - random.random(): Ngẫu nhiên trong khoảng từ 0.0 đến 1.0 (không bao gồm 1.0) - random.uniform(a, b): Tạo số thực ngẫu nhiên trong khoảng (a, b). - random.choice(seq): Chọn ngẫu nhiên một phần tử từ một chuỗi, danh sách, hoặc tuple. - random.randint(a, b): Tạo ra một số nguyên ngẫu nhiên trong khoảng từ a đến b - random.shuffle(x): Trộn ngẫu nhiên các phần tử trong một danh sách. - random.sample(population, k): Chọn ngẫu nhiên k phần tử không trùng lặp từ một tập hợp (population). - random.seed(a): Thiết lập giá trị số ngẫu nhiên. Giúp bạn có thể tái tạo lại cùng một dãy số ngẫu nhiên. - random.gauss(mu, sigma): Tạo số ngẫu nhiên theo phân phối chuẩn.
==> Tham khảo: Moldum RanDom() : https://www.w3schools.com/python/module_random.asp
# random.choice
import random
fruits = ["apple", "banana", "cherry"]
qua_ngau_nhien = random.choice(fruits)
print(qua_ngau_nhien) # Output: Ví dụ: "banana"
# random.shuffle
import random
cards = [1, 2, 3, 4, 5]
random.shuffle(cards)
print(cards) # Output: Ví dụ: [3, 5, 1, 4, 2]////////////////////////////////////////////// Module Math /////////////////// - math.sqrt(x): Tính căn bậc hai của số x.
- math.pow(x, y): Tính x mũ y. - math.ceil(x): Làm tròn số x lên thành số nguyên nhỏ nhất lớn hơn hoặc bằng x. - math.floor(x): Làm tròn số x xuống thành số nguyên lớn nhất nhỏ hơn hoặc bằng x. - math.fabs(x): Tính giá trị tuyệt đối của số x. - math.sin(x), math.cos(x), math.tan(x): Tính giá trị sin, cos, tan của góc x (x tính bằng radian). - math.pi: Hằng số pi (π). - math.e: Hằng số Euler (e). - math.log(x): Tính logarit tự nhiên (cơ số e) của x. - math.log10(x): Tính logarit cơ số 10 của x. ==> Link_ThamKhao: https://www.w3schools.com/python/module_math.asp
////////////////////////////////////////////// module request /////////////////// ////////////////////////////////////////////// module date /////////////////// ////////////////////////////////////////////// File ///////////////////
- Mode trong file :
r : Mở để đọc. Mode mặc định
r+: Mở để đọc và ghi
w : Mở để ghi-Xóa hết text cũ-Không tồn tại tự tạo 1 file cùng tên
w+: Mở để Ghi Đọc -Xóa hết text cũ-Không tồn tại tự tạo 1 file cùng tên
a : Mở để ghi-Không tồn tại tư tạo file
a+: Mở để ghi và đọc -Không tồn tại tư tạo file
x : tạo file mới- Nhưng thất bại khi tồn tại file
b : Mở file chế độ nhị phân
- Kiểm tra file:
exists(path): Kiểm tra xem một file hoặc thư mục có tồn tại hay không (trong module os).
isdir(path): Kiểm tra xem một đường dẫn có phải là một thư mục hay không (trong module os).
isfile(path): Kiểm tra xem một đường dẫn có phải là một file hay không (trong module os).
remove(path): Xóa một file (trong module os).
rename(src, dst): Đổi tên hoặc di chuyển một file (trong module os).
- File:
read() : Đọc file
write() : Viết vào file
close() : đóng file
----------------------------------------------- File.csv-------------------------- File sử dụng bằng.csv: - khai báo thư viện: import csv (pip install csv) - THuộc tính: + next() : cho phép bạn bỏ qua dòng tiêu đề: + csv.QUOTE_ALL: Tất cả dấu ngoặc kép, dấu đặc biệt. + csv.QUOTE_MINIMAL: Chỉ bao quanh các trường có chứa dấu phẩy, dấu ngoặc kép hoặc ký tự đặc biệt khác. + csv.QUOTE_NONNUMERIC: Chỉ bao quanh các trường không phải là số. + csv.QUOTE_NONE: Không bao quanh bất kỳ trường nào.
- Đọc file csv:
+ csv.reader(<ten_file>) : đọc file trả về array
+ csv.DictReader(<ten_file>)
- Viết file csv:
+ csv.DictWriter(<tên_file> , <định_dạng>, <thuộc_tính> )
+ writeheader() : Cho phép bạn ghi hàng tiêu đề với cột
+ writerow({<định_dạng>: <chuyền_vào>}) : Cho phép bạn ghi dữ liệu vào hàng song song với tiêu đề
# ĐỂ ĐỌC ĐƯỢC TIẾNG VIỆT PHẢI CHUYỂN MÃ HÓA SANG UTF-8
# VD: with open('tung.csv', 'w+' , encoding='utf-8')////////////////////////////////////////////// try + except ///////////////////
- try excpet ValueError :
===> Sử lý ngoại lệ
- try suite :
===> đưa ra khả năng ngoại lệ có thể sử lý được nhiều ngoại lệ khác nhau
- try finally
////////////////////////////////////////////// numpy /////////////////// ////////////////////////////////////////////// tkinner /////////////////// ////////////////////////////////////////////// web python ///////////////////