1
2
3
4
5

    def my_function(*args, **kwargs):
        print("args:", args)
        print("kwargs:", kwargs)

    my_function(1, 2, 3, name="Alice", age=30)

1
2

a = 2
isinstance (a,int)# True

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 区别示例
class A:
    pass
class B(A):
    pass
 
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False

1
2
3
4
5
6
7
8

    str='123456789'

    print(str[0:-1])           # 输出第一个到倒数第二个的所有字符
    print(str[2:])             # 输出从第三个开始后的所有字符
    print(str[1:5:2])          # 输出从第二个开始到第五个且每隔一个的字符（步长为2）
    print(str * 2)             # 输出字符串两次
    print ("我叫%s今年 %d 岁!" % ('小明', 10))
                            # 格式化输出字符串

1
2
3
4
5
6

    list.append(obj)    # 在列表末尾添加新的对象
    list.extend(seq)     # 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
    list.remove(obj)     # 删除列表中某个值的第一个匹配项
    del list[index]      # 删除指定索引的元素
    list.pop(n)        # 从列表中删除某个元素（默认最后一个元素），并且返回该元素的值
    list.reverse()      # 反转列表

1
2
3
4

list.sort(cmp=None, key=None, reverse=False)
# cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
# key -- key 参数要求传递的是一个函数，用于提取每个元素的排序依据，该参数取自于可迭代对象中，指定可迭代对象中的一个元素（即元素的元素）来进行排序。
# reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）

1
2
3
4
5
6
7
8

# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
# 指定第二个元素排序
random.sort(key=takeSecond)
print(random)  # 输出：[(4, 1), (2, 2), (1, 3), (3, 4)]

1
2

sorted(iterable, key=None, reverse=False)
# iterable -- 待排序的可迭代对象。

1
2
3
4
5
6
7
8

def SortTuples( x ): # x is a list contain tuples
    return sorted(x,key=lambda item: item[1])

if __name__ == '__main__':
    l =  [('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)]
    m = SortTuples( l )
    print( m )
    assert m == [('Social sciences', 82), ('English', 88), ('Science', 90), ('Maths', 97)] 

1
2
3
4
5
6
7
8
9

    dictexp = {}
    dictexp['one'] = "1 - 菜鸟教程"
    dictexp[2]     = "2 - 菜鸟工具"

    print (dictexp['one'])       # 输出键为 'one' 的值
    print (dictexp[2])           # 输出键为 2 的值
    print (dictexp)              # 输出完整的字典
    print (dictexp.keys())       # 输出所有键
    print (dictexp.values())     # 输出所有值

1
2

    len(dictexp)      #计算字典元素个数  
    str(dictexp)      #输出字典可打印的字符串表示  

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

    dictexp = {'name': 'runoob', 'age': 7, 'class': {'name': '101', 'teacher': 'teacher1'}}

    # 访问 'class' 对应子字典中的键 'name' 的值
    print(dictexp['class']['name'])
    # 连续使用get()方法安全访问，避免因为键不存在导致程序崩溃（这当然也适用于普通字典）
    print(f"get:{dictexp.get('class', {}).get('name', 'default')}")  # 输出键为 'class' 的值中的键为 'name' 的值，如果不存在则返回'default'

    # 想要遍历到子字典中的所有键值对，需要循环嵌套
    for key, value in dictexp.items():
        print(f"key:{key}", f"value:{value}")
        if type(value) == dict:
            for k, v in value.items():
                print(f"subdict key:{k}", f"subdict value:{v}")

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

    # 生成器表达式
    (<表达式> for <变量> in <序列> if <条件>)
    #eg:
    numbers = [1, 2, 3, 4, 5, 6, 7, 8]
    even_numbers = (num for num in numbers if num % 2 == 0)
    print(list(even_numbers))  # 输出：[2, 4, 6, 8]//也可以用next方法或for循环
    # 列表推导式
    [<表达式> for <变量> in <序列> if <条件>]
    #eg:
    names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
    new_names = [name.upper()for name in names if len(name)>3]
    print(new_names)
    # 输出结果：['ALICE', 'JERRY', 'WENDY', 'SMITH']
    
    # 字典推导式
    {<键表达式>:<值表达式> for <变量> in <序列> if <条件>}
    #eg:
    d = {'a':1,'b':2,'c':3}
    new_d = {k:v for k,v in d.items() if v>1}
    print(new_d)
    # 输出结果：{'b': 2, 'c': 3}

1
2
3
4
5
6
7
8

    # 示例1
    x = lambda a, b : a * b
    print(x(5, 6))  # 输出：30

    # 示例2
    numbers = [1, 2, 3, 4, 5, 6, 7, 8]
    even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
    print(even_numbers)  # 输出：[2, 4, 6, 8]

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

    list=[1,2,3,4]
    it = iter(list)    # 创建迭代器对象
    # 使用next()函数获取迭代器中下一个元素
    for x in range(4):
        print (next(it))

    # 使用for循环获取迭代器中下一个元素
    for x in it:
        print (x, end=" ")

    # 直接读取列表
    for x in list:
        print (x, end=" ")
    
    # 三种方法结果都是1 2 3 4

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

    class MyNumbers:
    def __iter__(self): # 类私有方法，返回一个特殊的迭代器对象
        self.a = 1
        return self
    
    def __next__(self):
        if self.a <= 20: # 可以限定迭代次数
            x = self.a
            self.a += 1 # 可以客制化迭代生成值
            return x
        else:
            raise StopIteration # StopIteration 异常用于标识迭代的完成
    
    myclass = MyNumbers()
    myiter = iter(myclass)
    
    for x in myiter:
    print(x)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

    def countdown(n):
        while n > 0:
            yield n
            n -= 1
    
    # 创建生成器对象
    generator = countdown(5)

    # 使用 for 循环迭代生成器/也可以使用next()方法
    for value in generator:
        print(value)  # 输出:5 4 3 2 1

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

    # 这是装饰器函数，参数 func 传入被装饰的函数
    def logger(func):
        def wrapper(*args, **kwargs): # 传入被装饰函数func的各参数
            print('我准备开始执行：{} 函数了:'.format(func.__name__))
            
            func(*args, **kwargs)# 真正执行被装饰函数的是这行。

            print('我执行完了。')
        return wrapper # 注意需要返回包装函数

    @logger
    def add(x, y): # 被装饰的函数，实际上是logger的参数func
        print('{} + {} = {}'.format(x, y, x+y))

    add(2, 3)

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

    def repeat(n): # 传入装饰器参数
        def decorator(func):
            def wrapper(*args, **kwargs): # 传入被装饰函数func的各参数
                for i in range(n):
                    print('No.',i+1,end=' ')
                    func(*args, **kwargs)
            return wrapper
        return decorator

    @repeat(3) # 装饰器名称应为最外层
    def greet(name):
        print(f"Hello, {name}!")

    greet("Alice")

 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

    def say_hello(country): # 传入装饰器参数
        def deco(func):
            def wrapper(*args, **kwargs): # 传入被装饰函数func的各参数
                if country == "china":
                    print("你好!")
                elif country == "america":
                    print('hello.')
                else:
                    return

                func(*args, **kwargs)# 真正执行被装饰函数的一行

            return wrapper # 注意需要返回包装函数
        return deco # 注意需要返回次层装饰器函数

    # 小明，中国人
    @say_hello("china")
    def xiaoming():
        pass
    # jack，美国人
    @say_hello("america")
    def jack():
        pass

    xiaoming()
    print("------------")
    jack()

1
2
3
4
5
6
7
8
9

    x=10
    try:
        if x>5:
            raise NameError('HiThere')  # 抛出一个NameError异常。
    except NameError:
        print('An exception flew by!')
        raise # 不提供Exception参数，则重新抛出当前异常，程序中断于此。若删去该行，仍会执行下面语句输出y的值。
    y=6
    print(y)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

    class MyError(Exception):
        def __init__(self, value): # 覆盖类Exception的__init__方法
            self.value = value
        def __str__(self):
            return repr(self.value)
   
    try:
        raise MyError(2*2)
    except MyError as e:
        print('My exception occurred, value:', e.value)

1
2
3

    with open("myfile.txt") as f:
        for line in f:
            print(line, end="")

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

    class MyClass:
        def __init__(self, value):
            self.value = value

        def display_value(self):
            print(self.value)

    # 创建一个类的实例
    obj = MyClass(42) # self传入obj实例
    obj2 = MyClass(25) # self传入obj2实例
    # 调用实例的方法
    obj.display_value() # 输出 42
    obj2.display_value() # 输出 25

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

    class Desc:
        def __get__(self, ins, cls):
            print(self, ins, cls) # self参数为Desc类的实例，ins参数为Test类的实例，cls参数为Test类本身。
    class Test:
        x = Desc()
        def prt(self):
            print('self in Test: %s' % self)

    t0 = Test()
    t1 = Test()

    t0.prt()
    t1.prt()
    t0.x
    t1.x
    # 输出：
    # self in Test: <__main__.Test object at 0x000001>
    # self in Test: <__main__.Test object at 0x000002>
    # <__main__.Desc object at 0x000003> <__main__.Test object at 0x000001> <class '__main__.Test'>
    # <__main__.Desc object at 0x000003> <__main__.Test object at 0x000002> <class '__main__.Test'>
    # 说明：
    # 1. 实例化Test类时，t0和t1传入的self参数分别对应Test类的两个实例。
    # 2. Test类中的x = Desc()语句与self参数无关，因此不论是t0.x还是t1.x或Test.x，x都指向同一个Desc类的实例，即x是类Test的类属性。

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

    class people:
        # 定义构造方法
        def __init__(self, n, a):
            self.name = n
            self.age = a
        def speak(self):
            print("父类%s 说: 我 %d 岁。" % (self.name, self.age))

    # 单继承示例
    class student(people):
        grade = ''
        def __init__(self, n, a, g):
            # 调用父类的构函
            people.__init__(self, n, a)
            self.grade = g
        # 覆写父类的方法
        def speak(self):
            print("子类%s 说: 我 %d 岁了，我在读 %d 年级" % (self.name, self.age, self.grade))

    s0 = people('s0',18)
    s1 = student('s1',10,3)
    s0.speak()
    s1.speak()
    # 输出：父类s0 说: 我 18 岁。 子类s1 说: 我 10 岁了，我在读 3 年级

1
2
3
4
5

    import re
    pattern = re.compile(r'([a-z]+) ([a-z]+) ([a-z]+)', re.I)   # re.I 表示忽略大小写
    # 匹配三个单词的组合
    m = pattern.search('Hello World Wide Web')
    print(m.groups())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

    import re
    
    # 将匹配的数字乘以 2
    def double(matched):
        valueout = int(matched.group('value0'))
        return str(valueout * 2)
    
    s = 'A23G4HFD567'
    print(re.sub('(?P<value0>\d+)', double, s))  
    # (?P<name>...)：这是命名捕获组的语法。name 是指定的组名，... 是要捕获的正则表达式模式。
    # 此处即捕获由数字组成的字符串组value0，传递至double()函数

1
2
3
4
5
6
7
8
9

    import re

    pattern_mail=re.compile('[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+')
    pattern_num=re.compile('(\+?\d{1,3})?[-.\s]?(\d{3})[-.\s]?(\d{4})[-.\s]?(\d{4})')
    pattern_ip=re.compile('((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)')
    pattern_url= re.compile('https?://(?:www\.)?[a-zA-Z0-9./?=&_-]+')
    
    s = 'self表示类的实例（对象）自身，通过self参数ychuang317@163.com将类的实例传入+86-13706811848类的方法中，使得类的方法能255.255.255.0够访问和操作http://hych0317.github.io/hugoweb_auto所创建的各个实例的属性。'
    print(re.search(pattern_num, s).group(0))

 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

    import requests

    # GET请求
    response = requests.get('https://www.google.com')
    print(response.status_code)  # 输出状态码
    print(response.text)  # 输出unicode响应内容
    print(response.content)  # 输出响应内容
    print(response.json())  # 输出JSON格式响应内容

    # POST请求
    response = requests.post('https://httpbin.org/post', data={'key': 'value'})
    print(response.text)  # 输出响应内容

    # 上传文件
    files = {'file': open('report.xls', 'rb')}
    response = requests.post('https://httpbin.org/post', files=files)
    print(response.text)  # 输出响应内容

    # 自定义请求头
    headers = {'User-Agent': 'Mozilla/5.0'}  # 设置请求头
    params = {'key1': 'value1', 'key2': 'value2'}  # 设置查询参数
    data = {'username': 'example', 'password': '123456'}  # 设置请求体
    response = requests.post('https://www.runoob.com', headers=headers, params=params, data=data)  # 输出响应内容

    # 超时设置
    response = requests.get('https://www.google.com', timeout=5)
    print(response.text)  # 输出响应内容

 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

    import socket
    import time
    COD = 'utf-8'
    HOST = socket.gethostname()# 获取本地主机ip
    PORT = 21566 # 软件端口号
    BUFSIZ = 1024
    ADDR = (HOST, PORT)
    SIZE = 10
    tcpS = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 创建socket对象
    tcpS.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) # 加入socket配置，重用ip和端口
    tcpS.bind(ADDR) # 绑定ip和端口号到套接字
    tcpS.listen(SIZE)  # 监听链接，设置最大链接数
    while True:
        print("服务器启动，监听客户端链接")
        conn, addr = tcpS.accept()# 建立客户端链接
        print("链接的客户端", addr)
        while True:
            try:
                data = conn.recv(BUFSIZ) # 读取已链接客户的发送的消息
            except Exception:
                print("断开的客户端", addr)
                break
            print("客户端发送的内容:",data.decode(COD))
            if not data:
                break
            msg = time.strftime("%Y-%m-%d %X") # 获取结构化事件戳
            msg1 = '已接收到[%s]的内容:%s' % (msg, data.decode(COD))
            conn.send(msg1.encode(COD)) # 发送消息给已链接客户端
        conn.close() # 关闭客户端链接
    tcpS.closel()

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

    import socket
    import time
    HOST = socket.gethostname()# 获取本地主机ip
    PORT = 21566 # 服务端端口号
    BUFSIZ = 1024
    ADDR = (HOST, PORT)
    tcpCliSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 创建socket对象
    tcpCliSock.connect(ADDR) # 连接服务器
    while True:
        data = input('>>').strip()
        if not data:
            break
        tcpCliSock.send(data.encode('utf-8')) # 发送消息
        data = tcpCliSock.recv(BUFSIZ) # 读取消息
        if not data:
            break
        print(data.decode('utf-8'))
    tcpCliSock.close() # 关闭客户端

 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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

    import socket
    import threading

    # 客户端地址 名称
    addr_name = {}
    # 所有客户端
    all_clients = []
    # 名称 客户端
    name_client = {}

    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    host = socket.gethostname()
    port = 9999
    server.bind((host, port))
    server.listen(5)
    lock = threading.Lock()
    print("开启聊天室")

    def handle_sock(sock, addr):
        while True:
            try:
                data = sock.recv(1024)
                msg = data.decode("utf-8")
                print("send msg")
                from_name = addr_name[str(addr)]
                if msg.startswith('@'):
                    index = msg.index(' ')
                    # 私聊人
                    to_name = msg[1:index]
                    # 接收者客户端
                    to_sock = name_client[to_name]
                    # 发送的消息
                    to_msg = msg[index:]
                    send_one(to_sock, addr, from_name + ":" + to_msg)
                else:
                    # 群发消息
                    send_all(all_clients, addr, from_name + ":" + msg)
            except ConnectionResetError:
                exit_name = addr_name[str(addr)]
                exit_client = name_client[exit_name]
                all_clients.remove(exit_client)
                msg = exit_name + " 退出了群聊"
                send_all(all_clients, addr, msg)
                break

    def send_all(socks, addr, msg):
        for sock in socks:
            sock.send(msg.encode("utf-8"))

    def send_one(sock, addr, msg):
        sock.send(msg.encode("utf-8"))

    while True:
        sock, addr = server.accept()
        name = sock.recv(1024).decode("utf-8")
        addr_name[str(addr)] = name
        name_client[name] = sock
        all_clients.append(sock)
        hello = name + "加入了聊天室"
        send_all(all_clients, addr, hello)
        client_thread = threading.Thread(target=handle_sock, args=(sock, addr))
        client_thread.start()

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

    import socket
    import threading

    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    host = socket.gethostname()
    port = 9999
    s.connect((host, port))
    name = "cc"
    s.send(name.encode("utf-8"))

    def receive_handle(sock, addr):
        while True:
            data = sock.recv(1024)
            print(data.decode("utf-8"))

    # 开启线程监听接收消息
    receive_thread = threading.Thread(target=receive_handle, args=(s, '1'))
    receive_thread.start()

    while True:
        re_data = input()
        s.send(re_data.encode("utf-8"))