Python: Dari Pemula hingga Pro Bahagian 4

Pengendalian Fail: Belajar membaca daripada dan menulis ke fail

Pengendalian fail ialah kemahiran penting untuk mana-mana pengaturcara. setiap pembangun seharusnya boleh mengakses dan berinteraksi dengan data daripada sumber luaran dan melaksanakan pengiraan dan storan.

Fail digunakan untuk menyimpan data pada cakera. Ia boleh mengandungi teks, nombor atau data binari. Dalam Python, kami menggunakan fungsi dan kaedah terbina dalam untuk berfungsi dengan fail.

Untuk membuka fail, kami menggunakan fungsi open(). Ia memerlukan dua hujah utama:

• Laluan fail (nama)
• Mod (baca, tulis, tambah, dll.)

Mod biasa

• 'r': Baca (lalai)
• 'w': Tulis (timpa kandungan sedia ada)
• 'a': Tambah (menambah pada kandungan sedia ada)
• 'x': Penciptaan eksklusif (gagal jika fail sudah wujud)
• 'b': Mod binari
• '+': Terbuka untuk mengemas kini (membaca dan menulis)

Contoh:

file = open("scofield.txt", "w")

Dalam contoh ini, kami mencipta pembolehubah yang dipanggil fail dan kami berkata ia harus memanggil scofield.txt, di mana kami menambahkan "w" untuk menulis ganti apa sahaja yang tertulis di dalamnya.

Menulis ke Fail
Untuk menulis pada fail, gunakan kaedah write().

 file = open("scofield.txt", "w")
 file.write("Hello, World!")
 file.close()

Adalah penting untuk menutup fail selepas anda selesai untuk mengosongkan sumber sistem. Amalan yang lebih baik ialah menggunakan pernyataan dengan, yang menutup fail secara automatik.

 with open("scofiedl.txt", "w") as file:
    file.write("Hello, World!")

Selepas menulis ganti isi di dalam, kami menulis kod di atas tetapi menjadikannya lebih pendek, menggunakan arahan dengan buka tutup scofield.txt.

Membaca daripada Fail
Anda boleh menggunakan beberapa kaedah untuk membaca daripada fail.

read(): Reads the entire file
readline(): Reads a single line
readlines(): Reads all lines into a list

Contoh:

with open("scofield.txt", "r") as file:
    content = file.read()
    print(content)

Melampirkan pada Fail
Untuk menambah kandungan pada fail sedia ada tanpa menulis ganti, gunakan mod tambah:

with open("scofield.txt", "a") as file:
    file.write("\nThis is a new line.")

Anda boleh menambah pada fail sedia ada dan bukannya sentiasa menimpa fail sedia ada, yang merupakan pendekatan yang baik jika anda mempunyai projek yang sedang berjalan dan mahukan akses kepada kerja sebelumnya.

Untuk memahami sepenuhnya aspek pengendalian fail yang seterusnya ini, kita mesti menjeda pembelajaran kita dan mendalami Modul dan Perpustakaan.

Salah satu ciri utama yang menjadikan Python begitu serba boleh dan berkuasa ialah ekosistem modul dan perpustakaannya yang luas. Alat ini membolehkan anda memanjangkan kefungsian Python, menjadikan tugasan kompleks lebih mudah dan membolehkan anda menulis atur cara yang lebih cekap dan berkuasa.

Apakah itu Modul dan Perpustakaan?
Pada terasnya, modul dalam Python hanyalah fail yang mengandungi kod Python. Ia boleh menentukan fungsi, kelas dan pembolehubah yang boleh anda gunakan dalam program anda. Perpustakaan, sebaliknya, adalah koleksi modul. Fikirkan modul sebagai alatan individu, manakala perpustakaan ialah kotak alat yang mengandungi berbilang alatan berkaitan.

Tujuan utama modul dan perpustakaan adalah untuk mempromosikan kebolehgunaan semula kod. Daripada menulis segala-galanya dari awal, anda boleh menggunakan kod pratulis dan diuji untuk melaksanakan tugas biasa. Ini menjimatkan masa dan mengurangkan kemungkinan ralat dalam program anda.

Modul Terbina dalam
Python datang dengan satu set modul terbina dalam yang merupakan sebahagian daripada perpustakaan standard. Modul ini tersedia dalam setiap pemasangan Python, menyediakan pelbagai fungsi di luar kotak. Mari kita terokai beberapa contoh.

• Modul 'rawak'

Modul 'rawak' digunakan untuk menjana nombor rawak. Begini cara anda boleh menggunakannya:

import random

# Generate a random integer between 1 and 10
random_number = random.randint(1, 10)
print(random_number)

# Choose a random item from a list
fruits = ["apple", "banana", "cherry"]
random_fruit = random.choice(fruits)
print(random_fruit)

Dalam contoh ini, kami mula-mula mengimport modul rawak. Kemudian kami menggunakan fungsi randitnya untuk menjana integer rawak dan fungsi 'pilihannya' untuk memilih item rawak daripada senarai.

• Modul 'datetime':

Modul 'datetime' menyediakan kelas untuk bekerja dengan tarikh dan masa:

import datetime

# Get the current date and time
current_time = datetime.datetime.now()
print(current_time)

# Create a specific date
birthday = datetime.date(1990, 5, 15)
print(birthday)

Di sini, kami menggunakan modul datetime untuk mendapatkan tarikh dan masa semasa, dan untuk mencipta tarikh tertentu.

• Modul 'matematik'

Modul 'matematik' menyediakan fungsi matematik.

import math

# Calculate the square root of a number

sqrt_of_16 = math.sqrt(16)
print(sqrt_of_16)

# Calculate the sine of an angle (in radians)
sine_of_pi_over_2 = math.sin(math.pi / 2)
print(sine_of_pi_over_2)

Contoh ini menunjukkan penggunaan modul 'matematik' untuk melaksanakan pengiraan matematik.

Mengimport Modul
Terdapat beberapa cara untuk mengimport modul dalam Python:

Import keseluruhan modul

import random
random_number = random.randint(1, 10)

Import specific functions from a module

from random import randint
random_number = randint(1, 10)

Import all functions from a module (use cautiously)

from random import *
random_number = randint(1, 10)

Import a module with an alias

1. python import random as rnd random_number = rnd.randint(1, 10) ## Python External Libraries

While the standard library is extensive, Python's true power lies in its vast ecosystem of third-party libraries. These libraries cover various functionalities, from web development to data analysis and machine learning.

To use external libraries, you first need to install them. This is typically done using pip, Python's package installer. Here's an example using the popular 'requests' library for making HTTP requests.

Install the library

pip install requests

Use the library in your code

import requests

response = requests.get('https://api.github.com')
print(response.status_code)
print(response.json())

This code sends a GET request to the GitHub API and prints the response status and content.

Our response was a 200, which means success; we were able to connect to the server.

Creating Your Own Modules
You might want to organize your code into modules as your projects grow. Creating a module is as simple as saving your Python code in a .py file. For example, let's create a module called 'write.py'

The key is to ensure all your files are in a single directory so it's easy for Python to track the file based on the name.

 with open("scofield.txt", "w") as file:
    content = file.write("Hello welcome to school")

Now, you can use this module in another Python file, so we will import it to the new file I created called read.py as long as they are in the same directory.

import write

with open("scofield.txt", "r") as file:
    filenew = file.read()
    print(filenew)

Our result would output the write command we set in write.py.

The Python Path

When you import a module, Python looks for it in several locations, collectively known as the Python path. This includes.

1. The directory containing the script you're running
2. The Python standard library
3. Directories listed in the PYTHONPATH environment variable
4. Site-packages directories where third-party libraries are installed

Understanding the Python path can help you troubleshoot import issues and organize your projects effectively.

Best Practices

1. Import only what you need: Instead of importing entire modules, import specific functions or classes when possible.
2. Use meaningful aliases: If you use aliases, make sure they're clear and descriptive.
3. Keep your imports organized: Group your imports at the top of your file, typically in the order of standard library imports, third-party imports, and then local imports.
4. Be cautious with 'from module import ***'**: This can lead to naming conflicts and make your code harder to understand.
5. Use virtual environments: When working on different projects, use virtual environments to manage dependencies and avoid conflicts between different versions of libraries.

Modules and libraries are fundamental to Python programming. They allow you to leverage existing code, extend Python's functionality, and effectively organize your code.

Now you understand imports, let's see how it works with file handling.

import os

file_path = os.path.join("folder", "scofield_fiel1.txt")
with open(file_path, "w") as file:
    file.write("success comes with patience and commitment")

First, we import the os module. This module provides a way to use operating system-dependent functionality like creating and removing directories, fetching environment variables, or in our case, working with file paths. By importing 'os', we gain access to tools that work regardless of whether you're using Windows, macOS, or Linux.

Next, we use os.path.join() to create a file path. This function is incredibly useful because it creates a correct path for your operating system.

On Windows, it might produce "folder\example.txt", while on Unix-based systems, it would create "folder/scofield_file1.txt". This small detail makes your code more portable and less likely to break when run on different systems.
The variable 'file_path' now contains the correct path to a file named "example.txt" inside a folder called "folder".

As mentioned above, the with statement allows Python to close the file after we finish writing it.

Fungsi open() digunakan untuk membuka fail. Kami memberikannya dua hujah: laluan_fail kami dan mod "w". Mod "w" bermaksud mod tulis, yang akan mencipta fail jika ia tidak wujud atau menimpanya jika ada. Mod biasa lain termasuk "r" untuk dibaca dan "a" untuk tambahan.

Akhir sekali, kami menggunakan kaedah write() untuk meletakkan beberapa teks ke dalam fail kami. Teks "Menggunakan os.path.join untuk laluan fail" akan ditulis pada fail, menunjukkan bahawa kami telah berjaya mencipta dan menulis pada fail menggunakan laluan yang berfungsi pada mana-mana sistem pengendalian.

Jika anda menyukai kerja saya dan ingin membantu saya terus menjatuhkan kandungan seperti ini, belikan saya secawan kopi.

Jika anda rasa siaran kami menarik, cari lebih banyak siaran menarik di Blog Learnhub; kami menulis segala-galanya teknologi daripada pengkomputeran Awan kepada Frontend Dev, Cybersecurity, AI dan Blockchain.

Sumber

• Bermula dengan Folium
• 20 Sambungan Python Penting untuk Kod Visual Studio
• Menggunakan Python untuk Pengikisan Web dan Pengekstrakan Data
• Bermula dengan Python
• Mencipta Peta Interaktif dengan Folium dan Python

Atas ialah kandungan terperinci Python: Dari Pemula hingga Pro Bahagian 4. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!