Python Tutorial

1
2

    import my_module # python文件
    from my_module import my_object 

1
2
3
4

    [Variable] AggregateFunction([Value] for [item] in [collection])
    x =[1, 2,3, 4, 5]
    y =[ 2*a for a in x if a%2 ==0]
    y >> [4, 8]

1
2
3

    lambda arguments : expression
    fun1 = lambda a,b,c : a+b+c
    print(fun1(5,6,2))

1
2
3
4
5

    nums =[1,2,3,4,5]
    letters =['a', 'b', 'c','d','e']
    # 两个for 循环也是要熟练
    nums_letters =[[n, l] for n in nums for l in letters ]
    nums_letters

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

    number = 0
    for number in range(10):
       number = number + 1
    
       if number == 5:
          pass    # pass here
    
       print('Number is ' + str(number))
    
    print('Out of loop')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

    gen_exp =(x **2 for x in range(10) if x %2 ==0)
    for x in gen_exp:
      print(x)
    
    def my_gen():
      for x in range(5):
        yield x
    
    gen1 =my_gen()
    next(gen1)
    
    def my_generator1():
      yield 1
      yield 2
      yield 3
      
    my_gen =my_generator1()
    # 使用 next() 进行调用下一个
    next(my_gen)

1
2
3
4
5
6

    my_list.append('C') #adds at the end
    my_list[1] = 'D' #update
    my_list.pop(1) # removes
    
    mylist.pop() # 默认就是类似 栈的结构，就是pop 出来最后一个
    mylist.pop(0) # 当然也可以根据index 指定特定的 pop(delete) 的element

1
2

    del mylist[1:2] # 通过指定 index range 然后进行del
    mylist.sort() # 支持 sorting 然后是从小到大, 这个sort是一种操作，inplace 的操作

1
2
3
4
5
6
7
8
9

    my_dict =dict()
    my_dict['key'] ='value'
    or 
    my_dict ={'key': 'value', ...}
    
    for key in my_dict:
    # do something
    if 'some key' in my_dict:
    # do something

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class yrange:
    def __init__(self, n):
        self.i = 0
        self.n = n

    # 这个表明是一个 iterator，make an object iterable
    def __iter__(self):
        return self

    # 这个next 函数就被当做是 class的属性，可以被外部调用的，
    def next(self):
        if self.i < self.n:
            i = self.i
            self.i += 1
            return i
        else:
            raise StopIteration()

1
2
3
4
5

    aa =2
    bb =aa
    print(id(aa), id(bb)) # 相同
    bb =3
    print(id(aa), id(bb)) # 不同，因为把3 这个值重新复制给了变量bb

1
2
3
4
5

    list1 =['a', 'b']
    list2 =list1 # 这个是引用，所以和list1 是相同的
    list3 =copy.copy(list1)  # 这个id 和list1 不同
    list4 =copy.deepcopy(list1)# 这个id 和list1 不同 
    print(id(list1), id(list2), id(list3), id(list4))

1
2
3
4
5
6

    class ParentClass:
     def my_function(self):
       print 'I am here'
    
    class SubClass1(ParentClass): 
    class SubClass2(ParentClass): 

1

    class A(B,C):  #A implments B and C

1

    super(A, self).funcion_name()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

    # raise exceptions
    try:
      raise TyeError
    except:
      print('exception')
    
    # catching exceptions
    try:
      do_something()
    except:
      print('exception')
    # try/ catch /finally
    try:
      do_something()
    except TypeError:
      print('exception')
    finally:
      close_connections()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

>>> all(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0
True
>>> all(['a', 'b', '', 'd'])   # 列表list，存在一个为空的元素
False
>>> all([0, 1，2, 3])          # 列表list，存在一个为0的元素
False
   
>>> all(('a', 'b', 'c', 'd'))  # 元组tuple，元素都不为空或0
True
>>> all(('a', 'b', '', 'd'))   # 元组tuple，存在一个为空的元素
False
>>> all((0, 1, 2, 3))          # 元组tuple，存在一个为0的元素
False
   
>>> all([])             # 空列表
True
>>> all(())             # 空元组
True

1
2

# type envelopes: List[List[int]]
envelopes.sort(key =lambda x:(x[0], -x[1]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import csv 
filename = "my_data.csv"
fields = [] 
rows = [] 

with open(filename, 'r') as csvfile: 
    csvreader = csv.reader(csvfile) 
    # 如果单单是这个for，那么内存是消耗比较大的
    # fields = csvreader.next() 
    for row in csvreader: 
        rows.append(row)
for row in rows[:5]: 
    print(row)

# Writing to csv file 
with open(filename, 'w+') as csvfile: 
    csvwriter = csv.writer(csvfile) 
    csvwriter.writerow(fields) 
    csvwriter.writerows(rows)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

import pandas as pd
from dicttoxml import dicttoxml
import json
# Building our dataframe
data = {'Name': ['Emily', 'Katie', 'John', 'Mike'],
        'Goals': [12, 8, 16, 3],
        'Assists': [18, 24, 9, 14],
        'Shots': [112, 96, 101, 82]
        }

df = pd.DataFrame(data, columns=data.keys())
# Converting the dataframe to a dictionary
# Then save it to file
data_dict = df.to_dict(orient="records")
with open('output.json', "w+") as f:
    json.dump(data_dict, f, indent=4)

# Converting the dataframe to XML
# Then save it to file
xml_data = dicttoxml(data_dict).decode()
with open("output.xml", "w+") as f:
    f.write(xml_data)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import json
import pandas as pd

# Read the data from file
# We now have a Python dictionary
with open('data.json') as f:
    data_listofdict = json.load(f)
    
# We can do the same thing with pandas
data_df = pd.read_json('data.json', orient='records')

# We can write a dictionary to JSON like so
# Use 'indent' and 'sort_keys' to make the JSON
# file look nice
with open('new_data.json', 'w+') as json_file:
    json.dump(data_listofdict, json_file, indent=4, sort_keys=True)

# And again the same thing with pandas
export = data_df.to_json('new_data.json', orient='records')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

if __name__ =="__main__":

    # 输入输出 n*n 的arrar
    """

    n =int(input())

    arr =[[0]*n] *n

    # 在python3 中需要 exactly 的注意这种分割，输入的时候要及其的小心
    for i in range(n):
        arr[i] = input().split(" ")
        arr[i] =[int(a) for a in arr[i]] # 转成 int 类型

    print(arr)
    
    """
    # 输入和输出 n*m 的数组
    n =int(input())
    m =int(input())

    arr =[[0]*m]*n

    for i in range(n):
        arr[i] =input().split(" ")
        arr[i] =[int(a) for a in arr[i]]

    print(arr)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

#python 中传递的是值 还是引用
def quick_sort(nums, l, r):
    if l>= r: return 
    left, right =l, r
    
    key =nums[l]
    while(l<r):
        while(l <r and nums[r] >= key): r -=1
        nums[l] =nums[r]
        while(l <r and nums[l] <= key): l +=1
        nums[r] =nums[l]
    nums[l] =key
    
    quick_sort(nums, left, l -1)
    quick_sort(nums, l +1, right)

if __name__ =="__main__":
    n =int(input())
    nums =list(map(int, input().split()))
    quick_sort(nums, 0, len(nums)-1)
    #print(nums)
    print(" ".join(list(map(str, nums))))

1
2
3

name = "Eric"
age = 74
print("Hello, %s. You are %s." % (name, age))

1
2
3
4
5
6
7

first_name = "Eric"
last_name = "Idle"
age = 74
profession = "comedian"
affiliation = "Monty Python"
"Hello, %s %s. You are %s. You are a %s. You were a member of %s." % (first_name, last_name, age, profession, affiliation)

1
2
3
4
5
6

"Hello, {}. You are {}.".format(name, age) # 默认的顺序
"Hello, {1}. You are {0}.".format(age, name) # 按照index 的顺序

# 传入的 dict 的顺序
 person = {'name': 'Eric', 'age': 74}
 "Hello, {name}. You are {age}.".format(name=person['name'], age=person['age'])

1

print(("Hello, {first_name} {last_name}. You are {age}. " +"You are a {profession}. You were a member of {affiliation}.") .format(first_name=first_name, last_name=last_name, age=age,profession=profession, affiliation=affiliation))

1
2
3
4

name = "Eric"
age = 74
f"Hello, {name}. You are {age}."
F"Hello, {name}. You are {age}." #  也可以使用大写的字母F

1
2
3
4
5
6

f"{2 * 37}"

def to_lowercase(input):
	return input.lower()
name = "Eric Idle"
f"{to_lowercase(name)} is funny."

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Comedian:
    def __init__(self, first_name, last_name, age):
        self.first_name = first_name
        self.last_name = last_name
        self.age = age

    def __str__(self):
        return f"{self.first_name} {self.last_name} is {self.age}."

    def __repr__(self):
        return f"{self.first_name} {self.last_name} is {self.age}. Surprise!

1
2

f"{new_comedian}"
f"{new_comedian!r}"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

from datetime import datetime
if __name__ == "__main__":
    nb = 1
    print (str(nb))
    #1
    print (repr(nb))
    #1
    print '*' * 20
#********************
    chaine = "hello world"
    print (str(chaine))
    #hello world
    print (repr(chaine))
    #'hello world'
    print '*' * 20
#********************
    d_cur = datetime.now()
    print (str(d_cur))
    #2019-03-14 12:01:44.377000
    print (repr(d_cur))
    #datetime.datetime(2019, 3, 14, 12, 1, 44, 377000)
    print '*' * 20
    #********************

1
2
3
4
5
6
7

import timeit
timeit.timeit("""name = "Eric" age = 74 '%s is %s.' % (name, age)""", number = 10000)
# 0.003324444866599663
timeit.timeit("""name = "Eric"age = 74'{} is {}.'.format(name, age)""", number = 10000)
# 0.004242089427570761
timeit.timeit("""name = "Eric"age = 74f'{name} is {age}.'""", number = 10000)
# 0.0024820892040722242

1
2
3
4
5

f'''Eric Idle'''
f"""Eric Idle""" # 注意是三对
# 'Eric Idle'
f"The \"comedian\" is {name}, aged {age}."
# 'The "comedian" is Eric Idle, aged 74.'

1
2

comedian = {'name': 'Eric Idle', 'age': 74}
f"The comedian is {comedian['name']}, aged {comedian['age']}."

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Foo(object):
	bar = 123

	def __init__(self, bob):
		self.bob = bob

print(Foo.bar)  # 123

foo = Foo(456)
print(foo.bob)  # 456

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

class Foo(object):
	_bar = 123

	def __init__(self, bob):
		self._bob = bob


class Son(Foo):
	
	def print_bob(self):
		print(self._bob)

	@classmethod
	def print_bar(cls):
		print(cls._bar)


Son.print_bar()  # 123

son = Son(456)
son.print_bob()  # 456

1
2
3
4

print(Son._bar)  # 123

son = Son(456)
print(son._bob)  # 456

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

class Foo(object):
	__bar = 123

	def __init__(self, bob):
		self.__bob = bob


class Son(Foo):
	
	def print_bob(self):
		print(self.__bob)  # Error

	@classmethod
	def print_bar(cls):
		print(cls.__bar)  # Error


print(Son.__bar)  # Error

son = Son(456)
print(son._bob)  # Error

1
2
3
4

class Foo(object):
	__bar = 123

print(Foo._Foo__bar)  # 123

1
2
3
4
5

class F:
    __name = "xurui"
f = F()
result = f._F__name          ##通过这个方式可以从外部访问...
print(result) 

1
2
3
4
5

class Foo(object):
	__bar__ = 123


print(Foo.__bar__)  # 123

1
2
3

class Foo(object):
	__ = 123
print(Foo.__)  # 123

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class ProtectMe(object):
    def __init__(self):
       self.me = "wxx"
       self.__name = "zixin"
    @property
    def name(self):
      return self.__name

p = ProtectMe()
print p.name

1
2
3
4
5
6

__foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 __init__() 之类的。

_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *

__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class Site:
    def __init__(self, name, url):
        self.name = name       # public
        self.__url = url   # private
        # 这个是系统的方法
 
    def who(self):
        print('name  : ', self.name)
        print('url : ', self.__url)
 
    def __foo(self):          # 私有方法
        print('这是私有方法')
 
    def foo(self):            # 公共方法
        print('这是公共方法')
        self.__foo()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class A:
    def __init__(self, name):
        self.name = name
        print("父类的__init__方法被执行了！")
    def show(self):
        print("父类的show方法被执行了！")

class B(A):
    def __init__(self, name, age):
        super(B, self).__init__(name=name)
        self.age = age

    def show(self):
        super(B, self).show()

obj = B("jack", 18)
obj.show()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

class Animal:
    def kind(self):
        print("i am animal")
        
class Dog(Animal):
    def kind(self):
        print("i am a dog")
        
class Cat(Animal):
    def kind(self):
        print("i am a cat")

class Pig(Animal):
    def kind(self):
        print("i am a pig")

# 这个函数接收一个animal参数，并调用它的kind方法
def show_kind(animal):
    animal.kind()

d = Dog()
c = Cat()
p = Pig()

show_kind(d)
show_kind(c)
show_kind(p)

------------------
打印结果：

i am a dog
i am a cat
i am a pig

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

class Kls(object):
    def foo(self, x):
        print('executing foo(%s,%s)' % (self, x))

    @classmethod
    def class_foo(cls,x):
        print('executing class_foo(%s,%s)' % (cls,x))

    @staticmethod
    def static_foo(x):
        print('executing static_foo(%s)' % x)

ik = Kls()
# 实例方法
ik.foo(1)
print(ik.foo)
print('==========================================')
# 类方法
ik.class_foo(1)
Kls.class_foo(1)
print(ik.class_foo)
print('==========================================')
# 静态方法
ik.static_foo(1)
Kls.static_foo('hi')
print(ik.static_foo)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class A(object):
    bar = 1
    @classmethod
    def class_foo(cls):
        print 'Hello, ', cls
        print cls.bar

>>> A.class_foo()   # 直接通过类来调用方法
Hello,  <class '__main__.A'>
1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class A(object):
    bar = 1
    @staticmethod
    def static_foo():
        print 'Hello, ', A.bar

>>> a = A()
>>> a.static_foo()
Hello, 1
>>> A.static_foo()
Hello, 1

1
2
3
4

使用模块
使用 __new__
使用装饰器（decorator）
使用元类（metaclass）

1
2
3
4
5

# mysingleton.py
class My_Singleton(object):
    def foo(self):
        pass
my_singleton = My_Singleton()

1
2
3
4
5
6
7
8

class Singleton(object):
    _instance = None
    def __new__(cls, *args, **kw):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kw)  
        return cls._instance  
class MyClass(Singleton):  
    a = 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

from functools import wraps
def singleton(cls):
    instances = {}
    @wraps(cls)
    def getinstance(*args, **kw):
        if cls not in instances:
            instances[cls] = cls(*args, **kw)
        return instances[cls]
    return getinstance
@singleton
class MyClass(object):
    a = 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#第一种方法 python 读取矩阵文件

# 单精度是32 位，双精度是64位
def read_file(file1):

    f =open(file1)
    matrix=[]

    while True:

        line =f.readline()
        if not line: break

        line=line.strip()
        line =line.split(",")
        line =map(float, line) # 这里转化成float 就是ok的
        matrix.append(line)
    f.close()

    # matrix =numpy.array(matrix)
    return matrix


# 第二种方法 基于numpy 的实现

path ="text.txt"
matrix =numpy.loadtxt(path)

b =numpy.reshape(matrix,(100, 2) )
b =numpy.reshape(matrix, (-1, 3, 2))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 纯python 实现
index= [i for i in range(len(train_x))]
random.shuffle(index)
train_x =train_x[index]
train_y  =train_y[index]

# 基于 numpy 实现

def shuffle_data(data):
    np.random.shuffle(data)
    
    return data

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import numpy as np
import os
 
img_path='./img/'
 
img_list=sorted(os.listdir(img_path))	#文件名按字母排序
img_nums=len(img_list)
for i in range(img_nums):
    img_name=img_path+img_list[i]
    print(img_name)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import numpy as np
import os
img_path='./img/'
 
img_list=os.listdir(img_path)
img_list.sort()
img_list.sort(key = lambda x: int(x[:-4])) ##文件名按数字排序
img_nums=len(img_list)
for i in range(img_nums):
    img_name=img_path+img_list[i]
    print(img_name)

1
2
3
4
5
6
7

heapq.heappush(heap, item) 把item添加到heap中（heap是一个列表）
heapq.heappop(heap) 把堆顶元素弹出，返回的就是堆顶
heapq.heappushpop(heap, item) 先把item加入到堆中，然后再pop，比heappush()再heappop()要快得多
# 这比较好用，不用自己维护 pushpop 操作
heapq.nlargest(n, iterable, key=None) 返回最大的n个元素（Top-K问题）
heapq.nsmallest(n, iterable, key=None) 返回最小的n个元素（Top-K问题）
# 如果写成了这样，那么寻找最大K 个元素，瞬间就没有了意义，有没有感觉到

1
2
3
4
5

import collections

# 就类似一个计数器了
hash =collections.defaultdict(int);

1
2
3
4
5

# python 中的入栈
stack =[1, 2, 3]
stack.append(4)

item =stack.pop() # 注意这个是直接返回，stack 中不再存在

1
2
3
4

# python 中 heap 的基本操作
heap =[] 
heapq.heappush(heap, val)
val = heapq.heappop(heap)

1
2
3
4
5
6
7

# 下面是常用操作
appendleft(x) # 添加x 到左侧
pop() # 移除并返回一个元素，右侧

# 以下体现的是双向编辑
append(x) # 添加 x 到右侧
popleft() # 移除并返回一个元素，左侧

1
2
3
4
5
6
7
8
9

from collections import deque
name=deque(["jean","li","na"])
name.append("yang")
name.append("chun")
print(name.popleft())    #不可以带参数
print(name)
 outputs:
jean
deque(['li', 'nana', 'yang', 'chun'])

1
2
3
4
5

q =[]
# 这个是入队操作
q.append('a')
# 出队
del q[0]

1
2
3
4
5
6

d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}
# 使用len(d) 可以获取长度

1
2

if 'Paul' in d:
	print(d['Paul'])

1

d.get("Paul")

1

d['Paul'] =20

1
2

for key in d:
	print key

1

'Bill' in s

1
2
3

s =set([1, 2, 3])
s.add(4)
s.remove(4) # 如果这个时候不存在，那么会保存

1
2
3

import sys
sys.maxsize #如果是整型
float(‘inf’) # 如果是浮点型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# 方案一：naive python implementation
text = "I need to count the number of word occurrences in a piece of text. How could I do that? Python provides us with multiple ways to do the same thing. But only one way I find beautiful."
word_count_dict = {}
for w in text.split(" "):
    if w in word_count_dict:
        word_count_dict[w]+=1
    else:
        word_count_dict[w]=1
# 方案二： use defaultdict 
from collections import defaultdict
word_count_dict = defaultdict(int) # 意味着value 是int 类型
for w in text.split(" "):
    word_count_dict[w]+=1

# 方案三：use counter
from collections import Counter
word_count_dict = Counter()
for w in text.split(" "):
    word_count_dict[w]+=1

1

word_count_dict.most_common(10) # 统计最常见的10 个单词

1
2
3
4

# Count Characters
Counter('abccccccddddd')
# Count List elements
Counter([1,2,3,4,5,1,2])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

from collections import defaultdict
# list of tuple
s = [ ('color', 'blue'), ('color', 'orange'), ('color', 'yellow'), ('fruit', 'banana'), ('fruit', 'orange'), ('fruit', 'banana')]
d =defaultdict(list) # 意味着value 是list 类型
for k, v in s:
    d[k].append(v)
print(d)

d =defaultdict(set) # 意味着 value 是set 类型
for k, v in s:
    d[k].add(v)
print(d)

1
2
3

a_dict =dict() # less pythonic
a_dict ={} # pythonic
a_dict.get("missing_key", "default value")

1
2
3

from collections import defaultdict
issubclass(defaultdict, dict)
# 是一个很好的工具类函数，辨别出两个class 的从属关系

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

word_count ={}
for word in doc.split():
    if word in word_count:
        word_count[word] +=1
    else:
        word_count[word] =1

# 如果使用defaultdict
from collections import defaultdict
word_count =defaultdict(int)
for word in doc.split():
    word_count[word] +=1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

dep = [('Sales', 'John Doe'),
       ('Sales', 'Martin Smith'),
       ('Accounting', 'Jane Doe'),
       ('Marketing', 'Elizabeth Smith'),
       ('Marketing', 'Elizabeth Smith'),
       ('Marketing', 'Adam Doe'),
       ('Marketing', 'Adam Doe'),
       ('Marketing', 'Adam Doe')]

dep_dd =defaultdict(set)
for department, employee in dep:
    dep_dd[department].add(employee)
dep_dd
# 如果想要继续遍历
for department, employee in dep_dd.items():
  print(department, employee)

# value 的数值是 float
dd =defaultdict(float)

1
2

dic ={1: "python", 2: "c++"}
dic.clear()

1
2
3

dic.pop(key)
dic.pop(key, None) # 这个应该是很规范的写法

1
2
3

del dic[key]
# 如果是一个 nested dictionary，那么 使用以下方式
del dic[outer-key][key-name-associated-with-the-value]

1

dic.popitem()

1

{val: key for key, val in dic.items()}

1
2
3
4

a ={}
print(type(a))
b =set()
print(type(b))

1

my_set = {1, 2, [3, 4]}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# Set union method
# initialize A and B
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# 1. union operation
print( A |B)
A.union(B)

# 2. intersection
print( A & B)
A.intersection(B)

# 3. set difference
print(A -B)
A.difference(B)

# 4. symmetric_difference() 其实就是异或含义
print(A^B)
# 这两个结果是一样的
A.symmetric_difference(B)
B.symmetric_difference(A)

1
2
3
4
5

set1 ={"apple", "banana", "cherry"}

for x in set1:
    print(x)
print(len(set1)) # 获取长度

1
2

all()  # returns True if all elements of the set are true (or if the set is empty)
any()  # returns True if any element of the set is true. If the set is empty, return False.