Circular traversal of dictionary

key traversing dictionary

dict = {"k1": "v1", "k2": "v2", "k3": "v3"}
keys = dict.keys()
print(keys)
for key in keys:
    print(key)

Note: key refers to the key of the dictionary, for example: 'k1', 'k2', 'k3'

Traverse the value of the dictionary

dict = {"k1": "v1", "k2": "v2", "k3": "v3"}
values = dict.values()
print(values)
for value in values:
    print(value)

Note: value refers to the value of the dictionary, for example: 'v1', 'v2', 'v3'

Traversing dictionary elements

dict = {"k1": "v1", "k2": "v2", "k3": "v3"}
items = dict.items()
print(items)

• The items method recombines the elements in the dictionary:
  • A list is created first
  • If there are several elements in the dictionary, several tuples are added to the list
  • Take the key of the element in the dictionary as the first element in the element and the value as the second element of the tuple

Traverse the key value pairs of the dictionary

dict = {"k1": "v1", "k2": "v2", "k3": "v3"}
items = dict.items()
for item in items:
    print(f'{item[0]}={item[1]}')

Key value pair: each key is followed by a corresponding value. When the corresponding key is pressed, the corresponding result will be output

k1=v1
k2=v2
k3=v3

aggregate

Create collection

Use {} or set() to create a collection, but only set() if you want to create an empty collection. Because {} is used to create an empty dictionary

s1={10,20,30,40,50}
print(s1)   #{40, 10, 50, 20, 30}  

s2={10,30,20,10,30,40,30,50}
print(s2)   #The {40, 10, 50, 20, 30} set automatically removes duplicate data

s3=set('abcdefg')
print(s3)   #{'c', 'b', 'a', 'e', 'f', 'd', 'g'}

s4=set()    
print(type(s4)) 	#< class' set '> creates an empty set

s5={}   
print(type(s5)) 	#< class' dict '> create an empty dictionary

characteristic:
1. The collection can remove duplicate data
2. The set data is out of order, so subscripts are not supported

Collection common operation methods

1. Add data

• add()

s3={'a','b','c'}
s3.add('d')	#increase
s3.add('b')	#Automatically remove duplicate values
print(s3)	#{'B', 'a','d ',' C '} output results are out of order

Note: because the collection has the function of removing duplicates, adding existing elements to the collection will be automatically removed by the collection

• update(), the appended data is a sequence

s1 = {10, 20}
# s1.update(100) # report errors
s1.update([100, 200])
s1.update('abc')
print(s1)	#{'c', 100, 'b', 200, 10, 'a', 20}

1. Delete data

• remove(), deletes the specified data in the collection. If the data does not exist, an error will be reported

s1 = {10, 20}
s1.remove(10)
print(s1) 	#{20}

s1 = {10, 20}
s1.remove(30)
print(s1)	#report errors

• pop(), then deletes a data in the collection and returns the data

s1 = {10, 20, 30, 40, 50}
del_num = s1.pop()
print(del_num)
print(s1)	#{10, 50, 20, 30} is deleted

Find data

• In: judge whether the data is in the set sequence
• Not in: judge that the data is not in the set sequence

s1 = {10, 20, 30, 40, 50}
print(10 in s1)	#True 10 prints true in the sequence
print(60 in s1)	#False 60 does not print false in the sequence
print(10 not in s1)	#False 10 prints false in the sequence
print(60 not in s1)	#True 60 does not print true in the sequence

Public operation

Common operator

operator	describe	Supported container types
+	merge	String, list, tuple
*	copy	String, list, tuple
in	Does the element exist	String, list, tuple, dictionary
not in	Does the element not exist	String, list, tuple, dictionary

+If both sides of the sign are numbers, it means addition, but it is used between strings, lists and tuples

print('3' + '5')	#35 addition
print('a' + 'b' + 'c')	#abc addition

l1 = ['a', 'b', 'c']
l2 = [10, 20, 30]
print(l1 + l2)	#['a ',' B ',' C ', 10, 20, 30] merge

t1 = (10, 20)
t2 = (30, 40)
print(t1 + t2)	#(10, 20, 30, 40) consolidation

If there are numbers on both sides of the * sign, it means addition, but it is used between strings, lists and tuples

str = '🙂'
print(str * 20)	#🙂🙂🙂🙂🙂🙂🙂🙂🙂🙂🙂🙂🙂🙂🙂🙂🙂🙂🙂🙂
l1 = ['a', 'b']
print(l1 * 5)	#['a', 'b', 'a', 'b', 'a', 'b', 'a', 'b', 'a', 'b']

• In or not in
  judge

str1 = 'aSDJFLKASDJFLASDJSD'
print('F' in str1)	#True

l1 = ['Xiao Ming', 'Xiao Hong', 'Xiaolan', 'Xiao Li']
name = 'Xiao Ming'
print(name in l1)	#True

Public method

function	describe
len()	Calculate the number of elements in the container
Del or del()	delete
max()	Returns the maximum value of the element in the container
min()	Returns the minimum value of the element in the container
range(start,end, step)	Generate a number from start to end in step for the for loop
enumerate()	The function is used to combine a traversable data object (such as list, tuple or string) into an index sequence, and list data and data subscripts at the same time. It is generally used in the for loop.

• len()

#character string
str1 = 'abcdefg'
print(len(str1))  # 7

#aggregate
s1 = {10, 20, 30}
print(len(s1))  # 3

#Dictionaries
dict1 = {'name': 'Rose', 'age': 18}
print(len(dict1))  # 2

• del()

#list
list1 = [10, 20, 30, 40]
del(list1[0])
print(list1)  # [20, 30, 40]

• max and min

l1 = [20, 22, 44, 1, 55, 77]
print(max(l1))	#77
#If it is a word comparison, compare the initials
l3 = ['zab', 'hello', 'word', 'nice', 'very']
print(max(l3))	#zab
#max cannot compare two different types of data
l2 = [1, 5, 33, 'a', 'v', 'z']
print(max(l2))	#report errors

• range

for i in range(1, 10, 3):
    print(i)	#1 4 7

Note: the sequence generated by range() does not contain the end number.

• enumerate()
  • Syntax: enumerate (traversable object, start=0)

Note: the start parameter is used to set the starting value of the subscript of traversal data, which is 0 by default.

list1 = ['a', 'b', 'c', 'd', 'e']
for item in enumerate(list1):
    print(item)	#(0,'a')(1,'b')(2,'c')(3,'d')(4,'e')

Container type conversion

• tuple()
  Function: convert a sequence into tuples

list1 = [10, 20, 30, 40, 50, 20]
s1 = {100, 200, 300, 400, 500}
print(tuple(list1))	#List tuple (10, 20, 30, 40, 50, 20)
print(tuple(s1))	#Set tuple (100, 200, 300, 400, 500)

• set()
  Function: convert a sequence into a set

list1 = [10, 20, 30, 40, 50, 20]
t1 = ('a', 'b', 'c', 'd', 'e')
print(set(list1))	#List to set {40, 10, 50, 20, 30}
print(set(t1))	#Tuple to set {'a','d ',' C ',' B ',' e '}

• list()
  Function: convert a sequence into a list

t1 = ('a', 'b', 'c', 'd', 'e')
s1 = {100, 200, 300, 400, 500}
print(list(t1))	#Tuple to list ['a ',' B ',' C ','d', 'e']
print(list(s1))	#Set transfer list [100, 200, 300, 400, 500]

be careful:

1. Collection can quickly complete list de duplication
2. Collection does not support subscripts