Câu hỏi của Python cho các nhà khoa học dữ liệu và kỹ sư phần mềm
Ảnh của Brooke Cagle trên unplashCách đây không lâu, tôi đã bắt đầu một vai trò mới là một nhà khoa học dữ liệu của người Hồi giáo, hóa ra là kỹ sư Python Python trong thực tế.
Tôi đã chuẩn bị nhiều hơn nếu tôi đã cải thiện vòng đời của Python, thay vì các hệ thống đề xuất trước.
Trong tinh thần đó, đây là câu hỏi và câu trả lời về cuộc phỏng vấn/chuẩn bị công việc Python của tôi. Hầu hết các nhà khoa học dữ liệu viết rất nhiều mã để điều này áp dụng cho cả các nhà khoa học và kỹ sư.
Cho dù bạn có phỏng vấn các ứng viên, chuẩn bị nộp đơn vào công việc hay chỉ cần cải thiện Python, tôi nghĩ rằng danh sách này sẽ là vô giá.
Câu hỏi không được đặt hàng. Hãy bắt đầu nào.
1. Sự khác biệt giữa danh sách và một tuple là gì?
Tôi đã được hỏi câu hỏi này trong mỗi cuộc phỏng vấn khoa học dữ liệu / Python mà tôi đã từng có. Biết câu trả lời như mặt sau của bàn tay của bạn.
- Danh sách là có thể thay đổi. Họ có thể được sửa đổi sau khi tạo.
- Tuples là bất biến. Khi một tuple được tạo, nó không thể thay đổi
- Danh sách có đơn đặt hàng. Chúng là một chuỗi được đặt hàng, thường là cùng loại đối tượng. IE: Tất cả các tên người dùng được đặt hàng trước ngày tạo,
def my_name[]:
9
print['chris']def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> chris
#=> naruto - Tuples có cấu trúc. Các loại dữ liệu khác nhau có thể tồn tại ở mỗi chỉ mục. IE: Bản ghi cơ sở dữ liệu trong bộ nhớ,
@logging
0
def my_name[]:
print['chris']@logging
def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> called.
#=> chris
#=> called.
#=> naruto
2. Nội suy chuỗi được thực hiện như thế nào?
Không nhập lớp
@logging1, có 3 cách để nội suy chuỗi.
def my_name[]:
print['chris']@logging
def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> called.
#=> chris
#=> called.
#=> naruto
name = 'Chris'# 1. f strings
print[f'Hello {name}']# 2. % operator
print['Hey %s %s' % [name, name]]# 3. format
print[
"My name is {}".format[[name]]
]
3. Sự khác biệt giữa những người khác là và và một người khác là gì?
Đầu sự nghiệp Python của tôi, tôi đã cho rằng đây là những con bọ Hello Hello. Vì vậy, đối với hồ sơ,
@logging2 kiểm tra danh tính và
def my_name[]:
print['chris']@logging
def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> called.
#=> chris
#=> called.
#=> naruto
@logging3 kiểm tra bình đẳng.
def my_name[]:
print['chris']@logging
def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> called.
#=> chris
#=> called.
#=> naruto
Chúng tôi sẽ đi qua một ví dụ. Tạo một số danh sách và gán chúng cho tên. Lưu ý rằng
@logging4 trỏ đến cùng một đối tượng với
def my_name[]:
print['chris']@logging
def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> called.
#=> chris
#=> called.
#=> naruto
@logging5 bên dưới.
def my_name[]:
print['chris']@logging
def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> called.
#=> chris
#=> called.
#=> naruto
a = [1,2,3]
b = a
c = [1,2,3]
Kiểm tra bình đẳng và lưu ý tất cả đều bằng nhau.
print[a == b]
print[a == c]
#=> True
#=> True
Nhưng họ có cùng một danh tính không? Không.
print[a is b]
print[a is c]
#=> True
#=> False
Chúng tôi có thể xác minh điều này bằng cách in ID đối tượng của họ.
print[id[a]]
print[id[b]]
print[id[c]]
#=> 4369567560
#=> 4369567560
#=> 4369567624
@logging6 có
def my_name[]:
print['chris']@logging
def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> called.
#=> chris
#=> called.
#=> naruto
@logging7 khác với
def my_name[]:
print['chris']@logging
def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> called.
#=> chris
#=> called.
#=> naruto
@logging5 và
def my_name[]:
print['chris']@logging
def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> called.
#=> chris
#=> called.
#=> naruto
@logging4.
def my_name[]:
print['chris']@logging
def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> called.
#=> chris
#=> called.
#=> naruto
4. Người trang trí là gì?
Một câu hỏi khác mà tôi đã được hỏi trong mỗi cuộc phỏng vấn. Nó rất xứng đáng với một bài đăng, nhưng bạn đã chuẩn bị nếu bạn có thể đi qua viết ví dụ của riêng mình.
Một trình trang trí cho phép thêm chức năng vào một chức năng hiện có bằng cách chuyển chức năng hiện có đó cho một trình trang trí, thực thi chức năng hiện có cũng như mã bổ sung.
Chúng tôi sẽ viết một người trang trí mà ghi lại khi một chức năng khác được gọi.
Viết chức năng trang trí. Điều này có một chức năng, [i for i in range[10]]
0, như một đối số. Nó cũng xác định một hàm,
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9][i for i in range[10]]
1, gọi
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9][i for i in range[10]]
2 và thực thi một số mã,
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9][i for i in range[10]]
3. Sau đó nó trả về chức năng mà nó xác định This takes a function,
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[i for i in range[10]]
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0, as an argument. It also defines a function, [i for i in range[10]]
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1, which calls [i for i in range[10]]
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2 and executes some code, [i for i in range[10]]
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
3. Then it return the function it defineddef logging[func]:
def log_function_called[]:
print[f'{func} called.']
func[]
return log_function_called
Hãy để viết các chức năng khác mà cuối cùng chúng tôi sẽ thêm người trang trí vào [nhưng chưa].
def my_name[]:
print['chris']def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> chris
#=> naruto
Bây giờ thêm người trang trí vào cả hai.
@logging
def my_name[]:
print['chris']@logging
def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> called.
#=> chris
#=> called.
#=> naruto
Xem cách bây giờ chúng ta có thể dễ dàng thêm đăng nhập vào bất kỳ chức năng nào chúng ta viết chỉ bằng cách thêm
[i for i in range[10]]
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
4 ở trên nó.5. Giải thích chức năng phạm vi
Phạm vi tạo ra một danh sách các số nguyên và có 3 cách để sử dụng nó.
Hàm mất 1 đến 3 đối số. Lưu ý rằng tôi đã bọc từng mức sử dụng trong khả năng hiểu danh sách để chúng ta có thể thấy các giá trị được tạo ra.
[i for i in range[10]]
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
5: Tạo số nguyên từ 0 đến số nguyên của Stop Stop.
: generate integers from 0 to the “stop” integer.[i for i in range[10]]
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[i for i in range[10]]
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
6: Tạo số nguyên từ số lượng khởi động của người Hồi giáo đến số nguyên của Stop Stop. : generate integers from the “start” to the “stop” integer.[i for i in range[2,10]]
#=> [2, 3, 4, 5, 6, 7, 8, 9]
[i for i in range[10]]
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
7: Tạo các số nguyên từ BẮT ĐẦU BẮT ĐẦU ĐẾN BẮT ĐẦU DỪNG LẠI trong khoảng thời gian của Bước Bước. : generate integers from “start” to “stop” at intervals of “step”.a = [1,2,3]
b = a
c = [1,2,3]
0Cảm ơn Searge Boremchuq đã đề xuất một cách pythonic hơn để làm điều này!
a = [1,2,3]
b = a
c = [1,2,3]
16 Sau đó tạo một thể hiện và tốc độ trở lại.
a = [1,2,3]
b = a
c = [1,2,3]
27. Sự khác biệt giữa các phương pháp phiên bản, tĩnh và lớp trong Python là gì?
Phương thức ví dụ: Chấp nhận tham số [i for i in range[10]]
8 và liên quan đến một thể hiện cụ thể của lớp. accept
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[i for i in range[10]]
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
8 parameter and relate to a specific instance of the class.Phương pháp tĩnh: Sử dụng [i for i in range[10]]
9 Trình trang trí, không liên quan đến một trường hợp cụ thể và được khép kín [don don sửa đổi thuộc tính lớp hoặc thể hiện] use
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[i for i in range[10]]
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
9 decorator, are not related to a specific
instance, and are self-contained [don’t modify class or instance attributes]Phương pháp lớp: Chấp nhận tham số [i for i in range[2,10]]
0 và có thể sửa đổi bản thân lớp accept
#=> [2, 3, 4, 5, 6, 7, 8, 9]
[i for i in range[2,10]]
#=> [2, 3, 4, 5, 6, 7, 8, 9]
0 parameter and can modify the class itselfChúng tôi sẽ minh họa cho sự khác biệt xung quanh một lớp
[i for i in range[2,10]]
#=> [2, 3, 4, 5, 6, 7, 8, 9]
1 hư cấu.a = [1,2,3]
b = a
c = [1,2,3]
3Lớp
[i for i in range[2,10]]
#=> [2, 3, 4, 5, 6, 7, 8, 9]
1 có một thuộc tính, [i for i in range[2,10]]
#=> [2, 3, 4, 5, 6, 7, 8, 9]
3, được đặt thành [i for i in range[2,10]]
#=> [2, 3, 4, 5, 6, 7, 8, 9]
4 theo mặc định. Mỗi trường hợp của [i for i in range[2,10]]
#=> [2, 3, 4, 5, 6, 7, 8, 9]
1 được khởi tạo bằng một thuộc tính [i for i in range[2,10]]
#=> [2, 3, 4, 5, 6, 7, 8, 9]
6. Nó cũng có 3 phương thức, một phương thức thể hiện, phương thức tĩnh và phương thức lớp.Hãy để khởi tạo một ví dụ của quán cà phê với
[i for i in range[2,10]]
#=> [2, 3, 4, 5, 6, 7, 8, 9]
6 của [i for i in range[2,10]]
#=> [2, 3, 4, 5, 6, 7, 8, 9]
8. Sau đó gọi phương thức thể hiện [i for i in range[2,10]]
#=> [2, 3, 4, 5, 6, 7, 8, 9]
9.a = [1,2,3]
b = a
c = [1,2,3]
4Bây giờ hãy gọi phương thức tĩnh. Các phương thức tĩnh có thể sửa đổi trạng thái lớp hoặc trường hợp để chúng thường được sử dụng cho các chức năng tiện ích, ví dụ, thêm 2 số. Chúng tôi đã sử dụng của chúng tôi để kiểm tra thời tiết .________ 100. Tuyệt quá!
a = [1,2,3]
b = a
c = [1,2,3]
5Bây giờ, hãy để sử dụng phương pháp lớp để sửa đổi chuyên môn của cửa hàng cà phê và sau đó là
[i for i in range[2,10]]
#=> [2, 3, 4, 5, 6, 7, 8, 9]
9. a = [1,2,3]
b = a
c = [1,2,3]
6Lưu ý cách
[i for i in range[2,10]]
#=> [2, 3, 4, 5, 6, 7, 8, 9]
9 được sử dụng để tạo a = [1,2,3]
b = a
c = [1,2,3]
03 nhưng bây giờ tạo ra a = [1,2,3]
b = a
c = [1,2,3]
04!8. Sự khác biệt giữa Func Func và và Func [] là gì?
Mục đích của câu hỏi này là để xem bạn có hiểu rằng tất cả các chức năng cũng là đối tượng trong Python.
a = [1,2,3]
b = a
c = [1,2,3]
7[i for i in range[10]]
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0 là đối tượng đại diện cho hàm có thể được gán cho một biến hoặc được truyền cho một hàm khác. [i for i in range[10]]
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2 với dấu ngoặc đơn gọi chức năng và trả về những gì nó xuất ra.9. Giải thích cách hoạt động của hàm bản đồ
a = [1,2,3]
b = a
c = [1,2,3]
07 Trả về một đối tượng MAP [một trình lặp] có thể lặp lại các giá trị được trả về từ việc áp dụng một hàm cho mọi phần tử theo một chuỗi. Đối tượng bản đồ cũng có thể được chuyển đổi thành một danh sách nếu được yêu cầu.a = [1,2,3]
b = a
c = [1,2,3]
8Ở trên, tôi đã thêm 3 vào mọi yếu tố trong danh sách.
Một độc giả đề nghị một triển khai Pythonic hơn. Cảm ơn Chrisjan Wust!
a = [1,2,3]
b = a
c = [1,2,3]
9Ngoài ra, cảm ơn Michael Graeme Short vì sự điều chỉnh!
10. Giải thích cách hoạt động của chức năng giảm
Điều này có thể khó khăn để quấn đầu bạn cho đến khi bạn sử dụng nó một vài lần.
a = [1,2,3]
b = a
c = [1,2,3]
08 có một chức năng và một chuỗi và lặp lại trên chuỗi đó. Trên mỗi lần lặp, cả phần tử hiện tại và đầu ra từ phần tử trước đó đều được chuyển đến hàm. Cuối cùng, một giá trị duy nhất được trả về.print[a == b]
print[a == c]
#=> True
#=> True
0a = [1,2,3]
b = a
c = [1,2,3]
09 được trả về là tổng của a = [1,2,3]
b = a
c = [1,2,3]
10.11. Giải thích cách hoạt động của hàm bộ lọc
Lọc theo nghĩa đen làm những gì tên nói. Nó lọc các yếu tố trong một chuỗi.
Mỗi phần tử được truyền đến một hàm được trả về theo trình tự xuất ra nếu hàm trả về
a = [1,2,3]
b = a
c = [1,2,3]
11 và bị loại bỏ nếu hàm trả về a = [1,2,3]
b = a
c = [1,2,3]
12.print[a == b]
print[a == c]
#=> True
#=> True
1Lưu ý làm thế nào tất cả các yếu tố không chia hết cho 2 đã được gỡ bỏ.
12. Python gọi bằng cách tham chiếu hoặc gọi theo giá trị?
Hãy chuẩn bị để đi xuống một hố thỏ của ngữ nghĩa nếu bạn google câu hỏi này và đọc một vài trang hàng đầu.
Tóm lại, tất cả các tên gọi theo tham chiếu, nhưng một số vị trí bộ nhớ giữ các đối tượng trong khi những vị trí khác giữ con trỏ đến các vị trí bộ nhớ khác.
print[a == b]
print[a == c]
#=> True
#=> True
2Hãy để xem cách thức hoạt động của nó với các chuỗi. Chúng tôi sẽ khởi tạo một tên và đối tượng, trỏ các tên khác vào nó. Sau đó xóa tên đầu tiên.
print[a == b]
print[a == c]
#=> True
#=> True
3Những gì chúng ta thấy là tất cả các tên này đều chỉ vào cùng một đối tượng trong bộ nhớ, được ảnh hưởng bởi
a = [1,2,3]
b = a
c = [1,2,3]
13.Ở đây, một ví dụ thú vị khác với một chức năng.
print[a == b]
print[a == c]
#=> True
#=> True
4Lưu ý cách thêm
a = [1,2,3]
b = a
c = [1,2,3]
14 vào chuỗi bên trong hàm đã tạo ra một tên mới và một đối tượng mới. Mặc dù tên mới có cùng tên tên gọi là tên hiện có.Cảm ơn Michael P. Reilly vì sự điều chỉnh!
13. Làm thế nào để đảo ngược một danh sách?
Lưu ý cách
a = [1,2,3]
b = a
c = [1,2,3]
15 được gọi trong danh sách và đột biến nó. Nó không trả lại danh sách đột biến.print[a == b]
print[a == c]
#=> True
#=> True
514. Làm thế nào để phép nhân chuỗi hoạt động như thế nào?
Hãy cùng xem kết quả của việc nhân chuỗi
a = [1,2,3]
b = a
c = [1,2,3]
16 với 3.print[a == b]
print[a == c]
#=> True
#=> True
6Chuỗi được liên kết với chính nó 3 lần.
15. Danh sách nhân hoạt động như thế nào?
Hãy cùng xem kết quả của việc nhân danh sách,
a = [1,2,3]
b = a
c = [1,2,3]
17 với 2.print[a == b]
print[a == c]
#=> True
#=> True
7Một danh sách được xuất ra chứa nội dung của [1,2,3] lặp lại hai lần.
16. Bản thân của người Viking đề cập đến trong một lớp học là gì?
Tự đề cập đến ví dụ của bản thân lớp. Đó là cách chúng tôi cung cấp cho các phương thức truy cập và khả năng cập nhật đối tượng mà chúng thuộc về.
Dưới đây, chuyển bản thân cho
a = [1,2,3]
b = a
c = [1,2,3]
18 cho chúng ta khả năng đặt a = [1,2,3]
b = a
c = [1,2,3]
19 của một thể hiện khởi tạo.print[a == b]
print[a == c]
#=> True
#=> True
817. Làm thế nào bạn có thể kết hợp danh sách trong Python?
Thêm 2 danh sách với nhau kết hợp chúng. Lưu ý rằng các mảng không hoạt động theo cùng một cách.
print[a == b]
print[a == c]
#=> True
#=> True
918. Sự khác biệt giữa một bản sao nông và sâu là gì?
Chúng tôi sẽ thảo luận về điều này trong bối cảnh của một đối tượng có thể thay đổi, một danh sách. Đối với các đối tượng bất biến, nông và sâu là có liên quan.
Chúng tôi sẽ đi qua 3 kịch bản.
i] tham chiếu đối tượng ban đầu. Điều này chỉ ra một tên mới, a = [1,2,3]
20, đến cùng một vị trí trong bộ nhớ mà
b = a
c = [1,2,3]a = [1,2,3]
21 điểm. Vì vậy, bất kỳ thay đổi nào chúng tôi thực hiện đối với
b = a
c = [1,2,3]a = [1,2,3]
21 cũng xảy ra với
b = a
c = [1,2,3]a = [1,2,3]
20. This points a new name,
b = a
c = [1,2,3]
a = [1,2,3]
b = a
c = [1,2,3]
20, to the same place in memory to which a = [1,2,3]
b = a
c = [1,2,3]
21 points. So any change we make to a = [1,2,3]
b = a
c = [1,2,3]
21 also occurs to a = [1,2,3]
b = a
c = [1,2,3]
20.print[a is b]
print[a is c]
#=> True
#=> False
0ii] Tạo một bản sao nông của bản gốc. Chúng ta có thể làm điều này với hàm tạo a = [1,2,3]
24 hoặc
b = a
c = [1,2,3]a = [1,2,3]
25 Pythonic hơn [cảm ơn Chrisjan Wust!]. We can do this with the
b = a
c = [1,2,3]
a = [1,2,3]
b = a
c = [1,2,3]
24 constructor, or the more pythonic a = [1,2,3]
b = a
c = [1,2,3]
25 [thanks Chrisjan Wust !].Một bản sao nông tạo ra một đối tượng mới, nhưng điền nó với các tham chiếu đến bản gốc. Vì vậy, việc thêm một đối tượng mới vào bộ sưu tập ban đầu,
a = [1,2,3]
b = a
c = [1,2,3]
26, không tuyên truyền đến a = [1,2,3]
b = a
c = [1,2,3]
27, nhưng việc sửa đổi một trong các đối tượng trong a = [1,2,3]
b = a
c = [1,2,3]
26 sẽ truyền đến a = [1,2,3]
b = a
c = [1,2,3]
27.print[a is b]
print[a is c]
#=> True
#=> False
1iii] Tạo một bản sao sâu. Điều này được thực hiện với a = [1,2,3]
30. 2 đối tượng hiện hoàn toàn độc lập và thay đổi đối với một trong hai không có ảnh hưởng đến đối thủ khác. This is done with
b = a
c = [1,2,3]
a = [1,2,3]
b = a
c = [1,2,3]
30. The 2 objects are now completely independent and changes to either have no affect on the other.print[a is b]
print[a is c]
#=> True
#=> False
219. Sự khác biệt giữa danh sách và mảng là gì?
Lưu ý: Thư viện tiêu chuẩn Python có một đối tượng mảng nhưng ở đây tôi đặc biệt đề cập đến mảng Numpy thường được sử dụng.
- Danh sách tồn tại trong thư viện tiêu chuẩn Python. Mảng được xác định bởi Numpy.
- Danh sách có thể được điền với các loại dữ liệu khác nhau tại mỗi chỉ mục. Mảng yêu cầu các yếu tố đồng nhất.
- Số học trên danh sách thêm hoặc xóa các yếu tố khỏi danh sách. Số học trên các hàm mảng trên mỗi đại số tuyến tính.
- Mảng cũng sử dụng ít bộ nhớ hơn và đi kèm với chức năng nhiều hơn đáng kể.
Tôi đã viết một bài viết toàn diện khác về mảng.
20. Làm thế nào để kết hợp hai mảng?
Hãy nhớ rằng, mảng không phải là danh sách. Các mảng là từ các chức năng vô dụng và số học như đại số tuyến tính.
Chúng ta cần sử dụng chức năng Numpy từ Concatenate để làm điều đó.
print[a is b]
print[a is c]
#=> True
#=> False
321. Bạn thích gì về Python?
Lưu ý đây là một câu hỏi rất chủ quan và bạn sẽ muốn sửa đổi câu trả lời của mình dựa trên những gì vai trò đang tìm kiếm.
Python rất dễ đọc và có một cách pythonic để làm mọi thứ, có nghĩa là một cách ưa thích rõ ràng và súc tích.
Tôi đã đối chiếu điều này với Ruby, nơi thường có nhiều cách để làm điều gì đó mà không cần hướng dẫn được ưu tiên.
22. Thư viện yêu thích của bạn là gì trong Python?
Cũng chủ quan, xem Câu 21.
Khi làm việc với rất nhiều dữ liệu, không có gì hữu ích như gấu trúc khiến việc thao túng và trực quan hóa dữ liệu trở nên dễ dàng.
23. Tên các đối tượng có thể thay đổi và bất biến
Bất biến có nghĩa là nhà nước không thể được sửa đổi sau khi tạo. Ví dụ là: int, float, bool, chuỗi và tuple.
Mutable có nghĩa là nhà nước có thể được sửa đổi sau khi tạo. Ví dụ là danh sách, dict và set.
24. Làm thế nào bạn sẽ làm tròn một số đến 3 thập phân?
Sử dụng hàm
a = [1,2,3]
b = a
c = [1,2,3]
31.print[a is b]
print[a is c]
#=> True
#=> False
425. Làm thế nào để bạn cắt một danh sách?
Ký hiệu cắt có 3 đối số,
a = [1,2,3]
b = a
c = [1,2,3]
32, trong đó bước là khoảng thời gian mà các phần tử được trả về.print[a is b]
print[a is c]
#=> True
#=> False
526. Dưa chua là gì?
Pickling là phương pháp tiếp theo của các đối tượng tuần tự hóa và không xác định trong Python.
Trong ví dụ dưới đây, chúng tôi tuần tự hóa và giải phóng một danh sách các từ điển.
print[a is b]
print[a is c]
#=> True
#=> False
627. Sự khác biệt giữa từ điển và JSON là gì?
Dict là Python DataType, một tập hợp các khóa và giá trị được lập chỉ định nhưng không có thứ tự.
JSON chỉ là một chuỗi theo một định dạng được chỉ định và được dự định để truyền dữ liệu.
28. Bạn đã sử dụng ORMS nào trong Python?
Các mô hình dữ liệu bản đồ MAP của Orms [Bản đồ quan hệ đối tượng] [thường là trong một ứng dụng] đến các bảng cơ sở dữ liệu và đơn giản hóa các giao dịch cơ sở dữ liệu.
Sqlalchemy thường được sử dụng trong bối cảnh của bình, và Django có ORM của riêng nó.
29. Làm thế nào để bất kỳ [] và tất cả [] hoạt động?
Bất kỳ trình tự nào và trả về true nếu bất kỳ phần tử nào trong chuỗi là đúng. takes a sequence and returns true if any element in the sequence is true.
Tất cả trả về chỉ đúng nếu tất cả các yếu tố trong chuỗi là đúng. returns true only if all elements in the sequence are true.
print[a is b]
print[a is c]
#=> True
#=> False
730. Từ điển hoặc danh sách có nhanh hơn để tra cứu không?
Nhìn lên một giá trị trong danh sách mất thời gian O [n] vì toàn bộ danh sách cần được lặp lại cho đến khi tìm thấy giá trị.
Nhìn lên một chìa khóa trong một từ điển mất thời gian O [1] vì nó là một bảng băm.
Điều này có thể tạo ra sự khác biệt lớn về thời gian nếu có rất nhiều giá trị nên từ điển thường được khuyến nghị cho tốc độ. Nhưng họ có những hạn chế khác như cần khóa duy nhất.
31. Sự khác biệt giữa mô -đun và gói là gì?
Mô -đun là một tệp [hoặc bộ sưu tập các tệp] có thể được nhập cùng nhau.
print[a is b]
print[a is c]
#=> True
#=> False
8Một gói là một thư mục của các mô -đun.
print[a is b]
print[a is c]
#=> True
#=> False
9Vì vậy, các gói là các mô -đun, nhưng không phải tất cả các mô -đun là các gói.
32. Làm thế nào để tăng và giảm một số nguyên trong Python?
Sự gia tăng và giảm có thể được thực hiện với
a = [1,2,3]
b = a
c = [1,2,3]
33 và a = [1,2,3]
b = a
c = [1,2,3]
34.print[id[a]]
print[id[b]]
print[id[c]]
#=> 4369567560
#=> 4369567560
#=> 4369567624
033. Làm thế nào để trả lại nhị phân của một số nguyên?
Sử dụng hàm
a = [1,2,3]
b = a
c = [1,2,3]
35.print[id[a]]
print[id[b]]
print[id[c]]
#=> 4369567560
#=> 4369567560
#=> 4369567624
134. Làm thế nào để loại bỏ các yếu tố trùng lặp khỏi danh sách?
Điều này có thể được thực hiện bằng cách chuyển đổi danh sách thành một bộ sau đó trở lại danh sách.
print[id[a]]
print[id[b]]
print[id[c]]
#=> 4369567560
#=> 4369567560
#=> 4369567624
2Lưu ý rằng các bộ sẽ không nhất thiết phải duy trì thứ tự của một danh sách.
35. Làm thế nào để kiểm tra xem một giá trị có tồn tại trong danh sách không?
Sử dụng
a = [1,2,3]
b = a
c = [1,2,3]
36.print[id[a]]
print[id[b]]
print[id[c]]
#=> 4369567560
#=> 4369567560
#=> 4369567624
336. Sự khác biệt giữa phụ lục và mở rộng là gì?
a = [1,2,3]
b = a
c = [1,2,3]
37 Thêm giá trị vào danh sách trong khi a = [1,2,3]
b = a
c = [1,2,3]
38 thêm các giá trị trong danh sách khác vào danh sách.print[id[a]]
print[id[b]]
print[id[c]]
#=> 4369567560
#=> 4369567560
#=> 4369567624
437. Làm thế nào để lấy giá trị tuyệt đối của một số nguyên?
Điều này có thể được thực hiện với chức năng
a = [1,2,3]
b = a
c = [1,2,3]
39.print[id[a]]
print[id[b]]
print[id[c]]
#=> 4369567560
#=> 4369567560
#=> 4369567624
538. Làm thế nào để kết hợp hai danh sách vào một danh sách các bộ dữ liệu?
Bạn có thể sử dụng chức năng
a = [1,2,3]
b = a
c = [1,2,3]
40 để kết hợp danh sách thành một danh sách các bộ dữ liệu. Điều này không được giới hạn chỉ bằng cách sử dụng 2 danh sách. Nó cũng có thể được thực hiện với 3 hoặc nhiều hơn.print[id[a]]
print[id[b]]
print[id[c]]
#=> 4369567560
#=> 4369567560
#=> 4369567624
639. Làm thế nào bạn có thể sắp xếp một từ điển theo khóa, theo thứ tự bảng chữ cái?
Bạn có thể sắp xếp một loại từ điển vì từ điển không có thứ tự nhưng bạn có thể trả lại một danh sách các bộ dữ liệu có các khóa và giá trị có trong từ điển.
print[id[a]]
print[id[b]]
print[id[c]]
#=> 4369567560
#=> 4369567560
#=> 4369567624
740. Làm thế nào để một lớp kế thừa từ một lớp khác trong Python?
Trong ví dụ dưới đây,
a = [1,2,3]
b = a
c = [1,2,3]
41, kế thừa từ a = [1,2,3]
b = a
c = [1,2,3]
42. Và với sự kế thừa đó là các phương thức thể hiện của lớp cha.print[id[a]]
print[id[b]]
print[id[c]]
#=> 4369567560
#=> 4369567560
#=> 4369567624
841. Làm thế nào bạn có thể loại bỏ tất cả khoảng trắng khỏi một chuỗi?
Cách dễ nhất là phân chia chuỗi trên khoảng trắng và sau đó gia nhập không có khoảng trống.
print[id[a]]
print[id[b]]
print[id[c]]
#=> 4369567560
#=> 4369567560
#=> 4369567624
92 độc giả đã đề xuất một cách pythonic hơn để xử lý điều này theo đạo đức Python mà
a = [1,2,3]
b = a
c = [1,2,3]
43. Nó cũng nhanh hơn vì Python không tạo ra một đối tượng danh sách mới. Cảm ơn еrdef logging[func]:
def log_function_called[]:
print[f'{func} called.']
func[]
return log_function_called
042. Tại sao bạn sẽ sử dụng Enumerate [] khi lặp lại trên một chuỗi?
a = [1,2,3]
b = a
c = [1,2,3]
44 cho phép chỉ số theo dõi khi lặp qua một chuỗi. Nó có nhiều pythonic hơn là xác định và tăng một số nguyên đại diện cho chỉ mục.def logging[func]:
def log_function_called[]:
print[f'{func} called.']
func[]
return log_function_called
143. Sự khác biệt giữa vượt qua, tiếp tục và phá vỡ là gì?
a = [1,2,3]
b = a
c = [1,2,3]
45 có nghĩa là không làm gì cả. Chúng tôi thường sử dụng nó vì Python không cho phép tạo một lớp, chức năng hoặc if-satement mà không có mã bên trong nó.Trong ví dụ dưới đây, một lỗi sẽ được ném mà không cần mã bên trong
a = [1,2,3]
b = a
c = [1,2,3]
46 vì vậy chúng tôi sử dụng a = [1,2,3]
b = a
c = [1,2,3]
45.def logging[func]:
def log_function_called[]:
print[f'{func} called.']
func[]
return log_function_called
2a = [1,2,3]
b = a
c = [1,2,3]
48 tiếp tục đến phần tử tiếp theo và tạm dừng thực thi cho phần tử hiện tại. Vì vậy, a = [1,2,3]
b = a
c = [1,2,3]
49 không bao giờ đạt được các giá trị trong đó a = [1,2,3]
b = a
c = [1,2,3]
50.def logging[func]:
def log_function_called[]:
print[f'{func} called.']
func[]
return log_function_called
3a = [1,2,3]
b = a
c = [1,2,3]
51 phá vỡ vòng lặp và trình tự không còn được lặp lại. Vì vậy, các yếu tố từ 3 trở đi không được in.def logging[func]:
def log_function_called[]:
print[f'{func} called.']
func[]
return log_function_called
444. Chuyển đổi phần sau cho vòng lặp thành một danh sách hiểu.
Vòng lặp
a = [1,2,3]
b = a
c = [1,2,3]
52 này.def logging[func]:
def log_function_called[]:
print[f'{func} called.']
func[]
return log_function_called
5Becomes.
def logging[func]:
def log_function_called[]:
print[f'{func} called.']
func[]
return log_function_called
6Sự hiểu biết danh sách thường được chấp nhận là Pythonic hơn nơi mà nó vẫn có thể đọc được.
45. Cho một ví dụ về toán tử ternary.
Toán tử ternary là câu lệnh một dòng nếu/khác.
Cú pháp trông giống như
a = [1,2,3]
b = a
c = [1,2,3]
53.def logging[func]:
def log_function_called[]:
print[f'{func} called.']
func[]
return log_function_called
746. Kiểm tra xem một chuỗi chỉ chứa số.
Bạn có thể sử dụng
a = [1,2,3]
b = a
c = [1,2,3]
54.def logging[func]:
def log_function_called[]:
print[f'{func} called.']
func[]
return log_function_called
847. Kiểm tra xem một chuỗi chỉ chứa các chữ cái.
Bạn có thể sử dụng
a = [1,2,3]
b = a
c = [1,2,3]
55.def logging[func]:
def log_function_called[]:
print[f'{func} called.']
func[]
return log_function_called
948. Kiểm tra xem một chuỗi chỉ chứa số và chữ cái.
Bạn có thể sử dụng
a = [1,2,3]
b = a
c = [1,2,3]
56.def my_name[]:0
print['chris']def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> chris
#=> naruto
49. Trả lại một danh sách các khóa từ một từ điển.
Điều này có thể được thực hiện bằng cách chuyển từ điển cho hàm tạo Python từ
a = [1,2,3]
b = a
c = [1,2,3]
24, a = [1,2,3]
b = a
c = [1,2,3]
24.def my_name[]:1
print['chris']def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> chris
#=> naruto
50. Làm thế nào để bạn trên và viết thường một chuỗi?
Bạn có thể sử dụng các phương thức chuỗi
a = [1,2,3]
b = a
c = [1,2,3]
59 và a = [1,2,3]
b = a
c = [1,2,3]
60.def my_name[]:2
print['chris']def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> chris
#=> naruto
51. Sự khác biệt giữa Remove, Del và Pop là gì?
a = [1,2,3]
b = a
c = [1,2,3]
61 Tháo giá trị khớp đầu tiên.def my_name[]:3
print['chris']def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> chris
#=> naruto
a = [1,2,3]
b = a
c = [1,2,3]
62 loại bỏ một phần tử theo chỉ mục.def my_name[]:4
print['chris']def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> chris
#=> naruto
a = [1,2,3]
b = a
c = [1,2,3]
63 loại bỏ một phần tử theo chỉ mục và trả về phần tử đó.def my_name[]:5
print['chris']def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> chris
#=> naruto
52. Cho một ví dụ về sự hiểu biết từ điển.
Dưới đây, chúng tôi sẽ tạo từ điển với các chữ cái của bảng chữ cái dưới dạng các phím và chỉ mục trong bảng chữ cái là giá trị.
def my_name[]:6
print['chris']def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> chris
#=> naruto
53. Xử lý ngoại lệ được thực hiện như thế nào trong Python?
Python cung cấp 3 từ để xử lý các ngoại lệ,
a = [1,2,3]
b = a
c = [1,2,3]
64, a = [1,2,3]
b = a
c = [1,2,3]
65 và a = [1,2,3]
b = a
c = [1,2,3]
66.Cú pháp trông như thế này.
def my_name[]:7
print['chris']def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> chris
#=> naruto
Trong ví dụ đơn giản dưới đây, khối
a = [1,2,3]
b = a
c = [1,2,3]
64 không thành công vì chúng ta không thể thêm số nguyên với các chuỗi. Khối a = [1,2,3]
b = a
c = [1,2,3]
65 đặt a = [1,2,3]
b = a
c = [1,2,3]
69 và sau đó là khối a = [1,2,3]
b = a
c = [1,2,3]
66 in a = [1,2,3]
b = a
c = [1,2,3]
71.def my_name[]:8
print['chris']def friends_name[]:
print['naruto']my_name[]
friends_name[]
#=> chris
#=> naruto
Sự kết luận
Bạn không bao giờ biết những câu hỏi nào sẽ được đưa ra trong các cuộc phỏng vấn và cách tốt nhất để chuẩn bị là có nhiều kinh nghiệm viết mã.
Điều đó nói rằng, danh sách này sẽ bao gồm hầu hết mọi thứ bạn sẽ được hỏi Python-Wise cho một nhà khoa học dữ liệu hoặc vai trò nhà phát triển Python trung cấp/trung cấp.
Tôi hy vọng điều này hữu ích cho bạn như viết nó cho tôi.
Có bất kỳ câu hỏi tuyệt vời mà tôi đã bỏ lỡ?