Python Core Functions¶

This book assumes that the reader already has a certain foundation in Python. Here is a brief explanation of some important usage that will be used in books.

Sequence in Python¶

In Python, the most basic data structure is a sequence. Each element in the sequence is assigned a sequence number - the position of the element, also known as an index. The first index is 0, and the second index is 1. And so on. The last element in the sequence is marked as' -1 ', the second to last element is marked as' -2', and so on.

Python includes 6 built-in sequences, including lists, tuples, strings, Unicode strings, buffer objects, and xrange objects. This article focuses on discussing lists and tuples. The main difference between lists and tuples is that lists can be modified, while tuples cannot.

All sequence types can perform certain specific operations. These operations include: indexing 、sliceing 、adding 、multiplying and check whether an element belongs to a member of the sequence (membership). In addition, Python also has built-in functions for calculating sequence length and finding the maximum and minimum elements.

All elements in the sequence are numbered - increasing from 0. These elements can be accessed separately by numbering, as follows:

Only sequences of the same type can be connected.

Sequence operation method¶

To check if a value is in the sequence, the in operator can be used.

In [1]:

permissions = 'rw'
'w' in permissions

Out[1]:

True

In [2]:

'x' in permissions

Out[2]:

False

Sequence de duplication : Regardless of the order, de duplication can be converted to a set.

In a for loop, it is common in Python to reference two variables simultaneously; How to achieve iterative display if [(1,2), (2,3), (3,4)] needs to be displayed?

List generation formula

List generation is actually a way of generating lists, which is built-in in Python;

Return a list of 1-10 square meters;

In [3]:

[ i*i for i in range(10) ]

Out[3]:

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Perform a function operation on each element of the list;

Sometimes we need to initialize a list nested with several lists, and the best option is to use list inference.

List deduction writing method¶

In [4]:

board = [['_'] * 3 for i in range(3)]
board

Out[4]:

[['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]

Use for...if statement, returns all even numbers between 1-10

In [5]:

[ i*i for i in range(1,10) if i%2==0]

Out[5]:

[4, 16, 36, 64]

Returns all prime numbers between 1-10, and the function for determining prime numbers is customized;

In [6]:

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

Out[6]:

[2, 4, 6, 8]

Dictionary in Python¶

A dictionary is another mutable container model that can store objects of any type.

Each key value (key=>value) in the dictionary is separated by a colon (:), and each pair is separated by a comma (,). The entire dictionary is enclosed in curly braces ({}), in the following format:

d = {key1 : value1, key2 : value2 }

The key must be unique, but the value does not need to be.

Values can take on any data type, but keys must be immutable, such as strings, numbers, or tuples.

Addition, deletion, and modification of dictionaries¶

Create dictionary

In [7]:

xiaoming = {
    "name":"xiaoming",
    "Age":17
}
xiaoming["name"]

Out[7]:

'xiaoming'

If the Key does not exist, an error will occur. A good way to handle this is to use the get() function:

In [8]:

xiaoming.get('name', None)

Out[8]:

'xiaoming'

If the Key exists, it will modify and add new key value pairs

In [9]:

xiaoming["Age"]=18

If the Key does not exist, it will modify the existing key value pairs

In [10]:

xiaoming["Gender"]=True

Delete. To avoid exceptions, parameters can be passed:

In [11]:

xiaoming.pop("name", None)
xiaoming

Out[11]:

{'Age': 18, 'Gender': True}

Traversal cycle of dictionary¶

The variable 'in dictionary' for the key used inside the 'for' loop

In [12]:

for k in xiaoming:
    print("%s: %s" % (k, xiaoming[k]))



Age: 18
Gender: True

Key mapping of a dictionary involves multiple values¶

Convert the following list into a dictionary

In [13]:

l = [('a',2),('b',3),('a',1),('b',4),('a',3),('a',1),('b',3)]

A dictionary is a mapping of a key to a single value, and the list above contains the same key. If you want a key to map multiple values, you need to put these multiple values into another sequence, such as a list or set, like the following:

In [14]:

d = {
    'a': [1, 2, 3],
    'b': [4, 5]
}
e = {
    'a': {1, 2, 3},
    'b': {4, 5}
}

You can easily use the defaultdict in the collections module to construct such a dictionary. One feature of defaultdict is that it automatically initializes the initial value corresponding to each key.

In [15]:

l = [('a',2),('b',3),('a',1),('b',4),('a',3),('a',1),('b',3)]
from collections import defaultdict
d = defaultdict(list)
for key, value in l:
    d[key].append(value)
d

Out[15]:

defaultdict(list, {'a': [2, 1, 3, 1], 'b': [3, 4, 3]})

Of course, this default container may not necessarily be a list, but can also be a collection set. Choose between using a list or a set based on your own needs. If you want to maintain the insertion order of elements, you should use a list. If you want to remove duplicate elements, you should use a set!

Merge Dictionary¶

Given a dictionary, then calculate the sum of all its numerical values.

1. Use the update() method to merge the second parameter with the first parameter

In [16]:

dict1 = {'a': 10, 'b': 8} 
dict2 = {'d': 6, 'c': 4}

dict2 merged dict1

In [17]:

dict2.update(dict1)

dict2

Out[17]:

{'d': 6, 'c': 4, 'a': 10, 'b': 8}

1. Using ** , the function imports parameters in dictionary form

In [18]:

dict3 ={**dict1, **dict2} 
dict3

Out[18]:

{'a': 10, 'b': 8, 'd': 6, 'c': 4}

Introduction to Common Python Modules¶

The following general libraries will be used in this book and will be used directly later without explanation. Let's focus on explaining here.

os Modules¶

OS, meaning operating system, is definitely a function related to the operating system, which can handle files and directories that we need to manually perform on a daily basis, For example: display all files in the current directory/delete a file/get file size.

Common functions of OS module：

1. Display the currently used platform

In [19]:

import os
os.name

Out[19]:

'posix'

1. Display the current working path of the Python script

In [20]:

os.getcwd()

Out[20]:

'/home/bk/jubook/book_python/ws_pytools/jubook_pytools/ch10_intro'

1. Return all files and directory names in the specified directory

In [21]:

os.listdir()

Out[21]:

['1.txt',
 'yeah',
 'testfile',
 'xiaoma.txt',
 '.ipynb_checkpoints',
 'a.txt',
 'sec50_essential.ipynb']

1. Delete a file

In [22]:

os.remove('testfile')

1. Generate multi-level recursive directory

In [23]:

os.makedirs('dirname/dirname')

1. Delete single level directory

In [24]:

os.rmdir('dirname/dirname')

1. Rename file

In [25]:

os.rename("dirname","yeah")

1. Run the shell command, note: This is to open a new shell, run the command, and when the command ends, close the shell

In [26]:

os.system('cd /usr/local && mkdir aaa.txt')

Out[26]:

256

1. Display the path delimiter on the current platform

In [27]:

os.sep

Out[27]:

'/'

1. Provide the line terminator used by the current platform

In [28]:

os.linesep

Out[28]:

'\n'

1. Retrieve system environment variables

In [29]:

os.environ

Out[29]:

environ({'LANG': 'en_US.UTF-8', 'LC_ALL': 'en_US.UTF-8', 'SUPERVISOR_SERVER_URL': 'unix:///var/run/supervisor.sock', 'USER': 'bk', 'JOURNAL_STREAM': '9:14319', 'SUPERVISOR_ENABLED': '1', 'SUPERVISOR_PROCESS_NAME': 'jubk', 'SUPERVISOR_GROUP_NAME': 'jubk', 'HOME': '/home/bk', 'PATH': '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin', 'INVOCATION_ID': '3104728a9ee248ee97d3072e3327c8b1', 'JPY_PARENT_PID': '765', 'TERM': 'xterm-color', 'CLICOLOR': '1', 'PAGER': 'cat', 'GIT_PAGER': 'cat', 'MPLBACKEND': 'module://ipykernel.pylab.backend_inline'})

os.path module contains many path related operations, which will be explained later.

sys module¶

The sys module in Python is a module used to handle the Python runtime environment, providing many functions and variables to handle different parts of the Python runtime environment.

The following is a list of common functions in the sys module：

• sys.argv: Implementing the transfer of parameters from outside the program to the program.

• sys.exit([arg]): Exit in the middle of the program, arg=0 is a normal exit.

• sys.getdefaultencoding(): Retrieve the current system code, which is usually set to ASCII by default.

• Set the system default encoding. When executing dir（sys） , you will not see this method. If it fails to execute in the interpreter, you can first execute reload(sys) , then execute setdefaultencoding('utf8') , and set the system default encoding to utf-8 . (See Setting System Default Encoding)

• sys.getfilesystemencoding(): Retrieve file system encoding method, return 'mbcs' on Windows and 'utf-8'on Mac.

• sys.path: Get the string collection of the specified module search path. You can place the written module in the obtained path to correctly find it when importing in the program.

• sys.platform: Get the current system platform.

• sys.stdin,sys.stdout,sys.stderr: stdin , stdout, and stderr variables contain the stream object corresponding to the standard I/O stream If you need better control over the output and prints cannot meet your requirements, they are what you need You can also replace them, at which point you can redirect the output and input to other devices ( device ), or process them in a non-standard way.

The above is the detailed content of what the Python sys module is. For more, please follow other related articles on PHP Chinese website!

re module¶

A regular expression is a special character sequence that can help you easily check whether a string matches a certain pattern. Python has added the re module since version 1.5, which provides Perl The regular expression pattern of style.

re module enables Python language to have all the regular expression functions.

Some important functions in module re

• compile(pattern[, flags]) Create pattern objects based on strings containing regular expressions
• search(pattern, string[, flags]) Search for patterns in a string
• match(pattern, string[, flags]) Match patterns at the beginning of a string
• split(pattern, string[, maxsplit=0]) Split strings based on patterns
• findall(pattern, string) Return a list containing all substrings in the string that match the pattern
• sub(pat, repl, string[, count=0]) Replace all substrings in the string that match the pattern pat with repl
• escape(string) Escaping all regular expression special characters in the string

datetime,time module¶

There are three main formats for time representation in the time module:

• timestamp Timestamp, which represents the offset calculated in seconds starting from January 1, 1970 at 00:00:00

In [30]:

import time
time.time()

Out[30]:

1598188833.2456446

• struct_time time tuple consists of nine element groups.

In [31]:

time.localtime()

Out[31]:

time.struct_time(tm_year=2020, tm_mon=8, tm_mday=23, tm_hour=21, tm_min=20, tm_sec=33, tm_wday=6, tm_yday=236, tm_isdst=0)

• format time Format time, the formatted structure makes time more readable. Including custom formats and fixed formats.

In [32]:

time.strftime("%Y-%m-%d %X")

Out[32]:

'2020-08-23 21:20:33'

datatime module has re encapsulated the time module, providing more interfaces and classes：date,time,datetime,timedelta,tzinfo。

• class retrieves today's date. datetime.date(year, month, day)

In [33]:

from datetime import *
date.today()

Out[33]:

datetime.date(2020, 8, 23)

• time class, create time. datetime.time(hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] )

In [34]:

time(23, 46, 10)

Out[34]:

datetime.time(23, 46, 10)

• datetime class, which is equivalent to combining date and time.

datetime.datetime (year, month, day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )

Return a timestamp object representing the current local time

In [35]:

datetime.now()

Out[35]:

datetime.datetime(2020, 8, 23, 21, 20, 33, 264151)

random module¶

The random module can generate random numbers or select random strings from sequences according to requirements.

• Generate a random integer int between n and m, with the result ∈[n, m) . Both n and m must be integers, and a>b or a==b, where a<b would result in a syntax error

In [36]:

import random
random.randint(1,100)

Out[36]:

6

• Generate a random floating point number float between 0 and 1, resulting in ∈[0.0, 1,0)

In [37]:

random.random()

Out[37]:

0.3098707281183486

math module¶

The math module in Python provides some basic mathematical running functions, such as finding strings, roots, logarithms, and so on.

• Return the value of PI

In [38]:

import math
math.pi

Out[38]:

3.141592653589793

• Return loga x (the logarithm of x with a as the base, if a is not written, it defaults to e) In [39]:

  math.log(2,5)

Out[39]:

0.43067655807339306

pprint module¶

Using the pprint function for formatting output in Python

PPRrint includes a "beauty printer" used to generate a beautiful view of data structures. The formatting tool generates some representations of data structures, which can not only be correctly parsed by the interpreter, but also be easy for humans to read. Output should be placed on one line as much as possible, and indentation is required when decomposing into multiple lines.

In [40]:

data = [(1,{'a':'A','b':'B','c':'C','d':'D'}),
    (2,{'e':'E','f':'F','g':'G','h':'H',
      'i':'I','j':'J','k':'K','l':'L'
      }),]
print(data)



[(1, {'a': 'A', 'b': 'B', 'c': 'C', 'd': 'D'}), (2, {'e': 'E', 'f': 'F', 'g': 'G', 'h': 'H', 'i': 'I', 'j': 'J', 'k': 'K', 'l': 'L'})]

In [41]:

from pprint import pprint
pprint(data)



[(1, {'a': 'A', 'b': 'B', 'c': 'C', 'd': 'D'}),
 (2,
  {'e': 'E',
   'f': 'F',
   'g': 'G',
   'h': 'H',
   'i': 'I',
   'j': 'J',
   'k': 'K',
   'l': 'L'})]

Exception handling¶

An exception is an event that occurs during program execution and affects the normal execution of the program.

In general, an exception occurs when Python is unable to process a program properly.

An exception is a Python object that represents an error.

When an exception occurs in a Python script, we need to catch and handle it, otherwise the program will terminate execution.

try/except grammar¶

Capturing exceptions can be done using the try/except statement The try/except statement is used to detect errors in the try statement block, allowing the except statement to capture exception information and handle it. If you don't want to end your program when an exception occurs, simply capture it in try .

Grammar：

Here is a simple syntax of try....except...else:

try:<statement>

First, run the try statement. If the try part raises a 'name' exception, run the except statement.

except <name>：<statement>

If a 'name' exception is raised, obtain additional data.

except <name>，<data>:<statement>

You can also use except without any exception type, which will capture all exceptions.

except:<statement>

The same except statement can also be used to handle multiple exception messages.

except(Exception1[, Exception2[,...ExceptionN]]]):

If no exceptions occur, run the else statement.

else:<statement>

The working principle of try is that when a try statement is started, Python marks it in the context of the current program, so that when an exception occurs, it can return here. The try clause is executed first, and what happens next depends on whether the exception occurs during execution.

If an exception occurs during the execution of a try statement, Python jumps back to try and executes the first except clause that matches the exception. Once the exception is handled, control flows through the entire try statement (unless a new exception is raised during exception handling).

If an exception occurs in the statement after try but there is no matching except clause, the exception will be passed to the upper level try or to the topmost level of the program (which will end the program and print the default error message).

If no exception occurs during the execution of the try clause, Python will execute the statement after the else statement (if there is an else), and then control flow through the entire try statement.

Here is a simple example, which opens a file and writes its contents without any exceptions:

In [42]:

try:
    fh = open("testfile", "w")
    fh.write("This is a test file used to test for anomalies!!")
except IOError:
    print ("Error: File not found or file read failed")
else:
    print ("Content successfully written to file")
    fh.close()



Content successfully written to file

In [ ]: