Introduction to Python quick programming # learning notes 05# | Chapter 5: combined data types (list, tuple, set and Dictionary)

2.1 create list

Python lists are created in two ways:

The first one can be directly created with "[]" brackets;
The second can be created with the built-in function list().

Example:

list1 = [] list2 = ['p', 'y', 't', 'h', 'o', 'n'] list3 = list() list4 = list('python') # Element 'python'

Note: when using list() to create a list, an error will be reported if the incoming data is not an iteratable type!

list3 = list(1) # 1 is not an iteratable object print(list3)

Error: TypeError:'int' object is not iterable

2.2 accessing list elements

The function of the list is to store multiple data at one time. Programmers can operate on these data: add, delete, modify and query

Lookup of list elements

Find (access) with subscript of list element

Format: sequence name [subscript]

The subscript is the address and number assigned to each element of the list in the computer memory.

name_list = ['Tom', 'Lily', 'Rose'] print(name_list[0]) # Tome print(name_list[1]) # Lily print(name_list[2])

Find (access) with function

slightly

2.3 adding list elements (append, extend and insert)

Adds the specified data to the list

Function 1: append() append data at the end of the function list

Syntax: list name. Append (data)

Example:

num = ['1' , '2', '3'] num.append('9') # String sequence num.append([11, 22]) # List sequence # Result 1: ['1', '2', '3', '9'] # Result 2: ['1', '2', '3', '9', [11, 22]] print(num)

Summary of append() function:
1. List data is modifiable -- lists are variable types
2. When the append() function appends data, if the data is a sequence, the entire sequence is appended to the end of the list.

Function 2: append data at the end of the function list

Syntax: list name. Extend (data)

Example:

name_list = ['Tom', 'Lily', 'Rose'] name_list.extend('xiaoming') # Breaks up a string data sequence and appends a single element to the end of the list name_list.extend(['xiaoming', 'xiaoming']) # Disassemble the list and append it to the end of the list # Result 1: ['Tom', 'Lily', 'Rose', 'x', 'I', 'a', 'o','m ',' I ',' n ',' g '] # Result 2: ['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaoming'] print(name_list)

extend() function summary
1. When the data appended by the extend() function is a sequence, the data in the data sequence is disassembled into a single element and appended to the end of the list one by one

Function 2: append data at the end of the insert function list

Syntax: list name. Insert (position subscript, data)

Example:

name_list = ['Tom', 'Lily', 'Rose'] name_list.insert(1, 'xiaoming') # Insert 'xiaoming' into the list where the subscript is 1 # Result 1: ['Tom', 'xiaoming', 'Lily', 'Rose',] print(name_list)

Summary of insert() function
1. The insert() function adds data at the specified location

2.4 element sorting (sort, reverse)

Inverse: reverse() function

Only the position of the elements in the list changes, and they are not sorted according to the size of the elements!!!

# reverse() list1 = [1, 4, 2, 3, 9] list1.reverse() # Results: [9,3,2,4,1] print(list1)

Sorting: sor() function

Syntax: list name. sort(key = None, reverse = False)

(the parameter key is used to sort the values of dictionary data series)

Example:

# sort() sort: ascending and descending list1 = [1, 4, 2, 3, 9] list1.sort() # Default ascending order list1.sort(reverse = False) # Ascending order list1.sort(reverse = True) # Descending order # Result 1: [1,2,3,4,9] # Result 2: [1,2,3,4,9] # Result 3: [9,4,3,2,1] print(list1)

Note: reverse indicates the collation. reverse = True in descending order (3, 2, 1), reverse = False (default) in ascending order (1, 2, 3)

2.5 delete list elements (del, pop, remove and clear)

del() function

Function: delete the whole target (can be list or function) and delete the data of the subscript of the specified list

Syntax: del list name and del (list name)

Example:

name_list = ['tom', 'lily', 'rose'] name_list2 = ['tom', 'lily', 'rose'] del name_list # del(name_list) # Result: an error is reported. NameError 'name_list' is not defined because the list is not deleted print(name_list) # del can delete the data of the specified subscript del name_list2[0] # Result: ['lily ',' Rose '] print(name_list2) #

pop() function

Function: delete the data of the specified subscript (the last data by default) and return the data.

Syntax: list name. Pop (subscript)

Example:

name_list = ['tom', 'lily', 'rose'] del_name = name_list.pop(1) # Delete the element 'lily' with sequence subscript 1 and return 'lily' # The result is: lily print(del_name) # The result is: ['Tom ',' Rose '] print(name_list)

remove() function

Function: remove() function deletes the first match of an element in the list.

Syntax: List naming. Remove (data)

Example:

name_list = ['tom', 'lily', 'rose'] name_list.remove('rose') # Result: ['Tom ',' Lily '] print(name_list)

clear() function

Function: clear list

Syntax: List naming. clear()

Example:

name_list = ['tom', 'lily', 'rose'] name_list.clear() # Result: [] empty list print(name_list)

2.6 list derivation

List derivation (function: simplify code; create or control regular lists)

# Requirements: 0, 1, 2, 4,... (create regular list) # 1. Cycle realization # 2. List derivation (function: simplify code; create or control regular list) # Method 1: while implementation list1 = [] i = 0 while i < 10: list1.append(i) i += 1 print(list1) # Mode 2: for implementation list2 = [] for i in range(10) list2.append(i) print(list2) # Mode 3: List derivation list3 = [i for i in range(10)] print(list3)

List derivation with if

# Requirement: list of 0-10 even data [0,2,4,6,8] # 1. Simple list derived range step size list1 = [i for i in range(0,10,2)] print(list1) # 2.for loop plus if to create regular list list2 = [] for i in range(10) if i % 2 == 0: list2.append(i) print(list2) # 3. Rewrite the for loop with the if code to the list derivation with if list3 = [i for i range(10) if i % 2 ==0] print(list3)

Multiple for loops implement list derivation

Requirements: create the following list

[(1, 0), (1, 1), (1, 2),(2, 0), (2, 1), (2, 2)]

# Requirements: [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)] # analysis: # Data 1:1 and 2 -- range (1,3) # Data 2:0 1 2 -- range (3) # Method 1: for nesting list2 = [] for i in range(1, 3): for j in range(3): list2.append((i, j)) print(list2) # Method 2: multiple for implementations list derivation list1 = [(i, j) for i in range(1, 3) for j in range(3)] print(list1)

3.1 application scenarios of tuples

Thinking: if you want to store multiple data, but these data cannot be modified, how do you operate?
A: list? A list can store multiple data at once, but the data in the list can be changed.

num = [10, 20 ,30] num[0] = 100 # Change the element subscript 0 in the list from 10 to 100

Note: a tuple can store multiple data, and the data in the tuple cannot be modified.

3.2 definition of tuple

Definition: tuples are defined in parentheses, and each data is separated by commas. The data can be of different data types (it is best to ensure that the data types in tuples are consistent).

t1 = (10, 'a', 1.2) # For multiple data type tuples, it is best to ensure that the data types in the tuples are consistent! t2 = (10,) # Single data tuple t3 = () # Empty tuple

Note: if the defined tuple has only one data, the comma "," after the element cannot be omitted, otherwise the data type is the data type of the data of the only element in parentheses.

t2 = (10,) # tuple t3 = (10) # integer t4 = ('hello') # character string

Common operations of tuples

Tuples can also be created by using the built-in function tuple(). When the function parameter list is empty, the function creates tuples, and when the parameter is an iteratable object, the function creates non empty tuples.

Sample code

t1 = tuple() # Create empty tuple t2 = tuple([1,2,3]) # Create tuples from lists t3 = tuple('python') # Create tuples ('p ',' y ','t', 'H', 'o', 'n') from strings t4 = tuple(range(5)) # Create tuples with iteratable objects (0,1,2,3,4) print(t1, t2,t3,t4)

Like the list, Python supports accessing elements of tuples through indexes and slices, and traversing element groups in a loop. The example code is as follows:

t1 = tuple() # Create empty tuple t2 = tuple([1,2,3]) # Create tuples from lists t3 = tuple('python') # Create tuples ('p ',' y ','t', 'H', 'o', 'n') from strings t4 = tuple(range(5)) # Create tuples with iteratable objects (0,1,2,3,4) print(t2[1]) # Access tuple elements by index print(t3[3:5]) # Group elements in a sliced way for data in t3: print(data, end='')

The output results are as follows:

1. Top ten singers

2. Magic cube array

4.1 creating collections

Create a collection using {} or set(), but if you want to create an empty collection, you can only use set(), because {} is used to create a dictionary.

# 1. Create a collection with data s1 = # Set has no subscript, set has no order print(s1) s2 = # The element data in the collection cannot be repeated (to reprint the data) print(s2) # duplicate removal # 2. Create an empty collection s3 = {} # Note: {} represents a dictionary print(s3) # Dictionary type s5 = set('abcdefg') # Result: the element data in the set is out of order print(s5) s4 = set() print(type(s4)) # set

4.2 common operations of collection - adding data (add and update)

s1 = #1. A set is a variable data sequence # add() s1.add(100) # Results: print(s1) # The collection has the function of de duplication. If the additional data is the existing data of the collection, nothing will be done s1.add(100) # Results: print(s1) # # update(): the added data is a sequence s1.update([10,20,30,40]) # Set s1 append list print(s1)

4.3 common operations of collection delete data (remove, dicard and pop)

The remove() function deletes the specified data in the collection. If the data does not exist, an error is reported.

s1 = s1.remove(10) print(s1) s1.remove(10) # report errors print(s1)

The discard() function deletes the specified data in the collection. If the data does not exist, no error will be reported.

s1 = s1.discard(10) print(s1) s1.discard(10) print(s1)

pop() function randomly deletes a data summarized in the collection and returns this data.

s1 = del_num = s1.pop() print(s1)

4.4 common operations of collection - find data

In: judge whether the data is in the set sequence
not in: judge that the data is no longer a collection sequence

s1 = print(10 in s1) # Return True print(10 not in s1) # Return False

5.1 create dictionary

Dictionary features:

• The symbol is brace {}
• The data is in the form of key value pairs
• Key value pairs are separated by commas

Sample program:

(create a dictionary with data and an empty dictionary)

# Create a dictionary with data dict1 = {'name':'Tom', 'age':'18', 12:'male'} # Create an empty dictionary dict2 = {} # Method 1 dict3 = dict() # Method 2 # dict3 = dict({'name':'Tom', 'age':'18', 'sexy':'male'}) # Method 2 print(dict1) print(type(dict1)) print(dict2) print(dict3)

Output results:

5.2 dictionary access (key value, get, keys, values and items)

Dictionary lookup (access)

Method 1: key value search

Note: if the current key exists, put back the value corresponding to the key; Otherwise, an error is reported

# Dictionary lookup (access) # Note: if the current key exists, put back the value corresponding to the key; Otherwise, an error is reported # Method 1: key value search dict1 = {'name': 'Tom', 'age': '18', 12:'male'} print(dict1['name']) print(dict1[12])

Method 2: function search

• get()
  Python provides a built-in method get(), which obtains the corresponding value from the dictionary according to the key. If the specified key does not exist, it returns the default value (default). The syntax format is as follows:
  Dictionary name. Get (key [, default])

# Method 2: find with get() function dict1 = {'name': 'Tom', 'age': '18', 12:'male'} print(dict1.get('name')) print(dict1.get(12))

Python dictionary data is divided into keys, values and elements (key value pairs). In addition to direct access by keys, python also provides built-in methods key(), values(), items() for accessing all keys, values and elements in the dictionary. The example code of these functions is as follows:

key() - get all keys in the dictionary
values() - get all values in the dictionary
items() - get all the elements in the dictionary

dict1 = {'name': 'Tom', 'age': '18', 12:'male'} print(dict1.keys()) # Use the keys() method to get all the keys print(dict1.values()) # Use the values() method to get all the values print(dict1.items()) # Use the items() method to get all the elements

The output results are as follows:

5.3 addition and modification of dictionary elements ('key = value 'and update)

Addition of dictionary elements:

Method 1: Dictionary variable name ['key'] = value

Method 2: Dictionary variable name. Update (key name = value)

# Method 1. Dictionary variable name ['key'] = value # dict1 = {'name': 'Tom', 'age': '18', 12:'male'} # dict1['sco'] = 100 # Add element # print(dict1) # Method 2: Dictionary variable name. Update (key name = value) dict1 = {'name': 'Tom', 'age': '18', 12:'male'} dict1.update(sexy = 'male') # Add element print(dict1)

Modification of dictionary elements:

The essence of modifying dictionary elements is to obtain values through keys, and then re assign values to the elements. The operation of modifying an element is similar to that of adding an element. The example code is as follows:

stu_dict = {'stu1': 'LAN LAN','stu2':'Honghong','stu3': 'Huang Huang'} print(stu_dict) stu_dict.update(stu3 = 'Xiao Hei') # Modify the element through update() stu_dict['stu2'] = 'Xiao Ming' # Modify element values by specifying keys print(stu_dict)

Run the code and the results are as follows:

5.4 deletion of dictionary elements (pop, popitem and clear)

Python supports modifying elements in the dictionary through the pop(), popitem(), and clear() functions

pop() method

Function: pop() method can delete the corresponding element in the dictionary according to the specified key. If the deletion is successful, this method returns the value of the target element

stu_dict = {'stu1': 'LAN LAN','stu2':'Honghong','stu3': 'Huang Huang'} print(stu_dict.pop('stu1')) print(stu_dict)

Run the program, and the output results are as follows:

popitem() method

Function: use this method to randomly delete elements in the dictionary. In fact, popitem() can delete elements randomly because dictionary elements are disordered and there is no distinction between "first item" and "last item". If the deletion is successful, the deleted coarse element is returned.

stu_dict = {'stu1': 'LAN LAN', 'stu2': 'Honghong', 'stu3': 'Huang Huang'} print(stu_dict.popitem()) print(stu_dict) print(stu_dict.update())

Run the program, and the output results are as follows:

clear() method

Function: clear() is used to clear the elements in the dictionary

stu_dict = {'stu1': 'LAN LAN', 'stu2': 'Honghong', 'stu3': 'Huang Huang'} stu_dict.clear() print(stu_dict)

The results are as follows:

5.5 dictionary derivation

The format and usage of the dictionary derivation are similar to those of the list derivation, except that the dictionary derivation is surrounded by braces "{}" and contains two parts of keys and values. The specific format is as follows:

{ new_key : new_value for key , value in dict.items()}

The dictionary derivation can be used to quickly exchange the positions of keys and values in the dictionary. The example code is as follows:

old_stu_dict = {'stu1': 'LAN LAN', 'stu2': 'Honghong', 'stu3': 'Huang Huang'} new_stu_dict = print(new_stu_dict)

Run the program, and the output results are as follows:

1. Youth has you

2. Mobile phone address book

Public operation and data sequence all support the operation mode.

Three aspects: operators, public methods and container type conversion

• operator

merge

str1 = 'aa' str2 = 'bb' list1 = [1, 2] list2 = [10, 20] t1 = (1, 2) t2 = (10, 20) dict1 = {'name':'pyton'} dict2 = {'age':'18'} print(str1 + str2) # The result was aabb print(list1 + list2) # The printout result is: [1,2,10,20] print(t1 + t2) # print(dict1 + dict2) # Error: the dictionary does not support merge operation

copy

str1 = 'a' list1 = ['hello'] t1 = ('world',) # *: copy print(str1 * 5) # Print 10 '-' print('-' * 10) print(list1 * 5) # The output result is: ['hello', 'hello', 'hello', 'hello'] print(t1 * 5)

Does the element exist

dict1 = {'name':'pyton','age':'19'} print('name' in dict1) print('name' not in dict1) print('name' in dict1.keys) print('name' not in dict1.keys) print('name' in dict1.values)

Add new comment

0 comments